gl_buffer_cache: Remove unused ReserveMemory method

Removes the alpha testing code from each fragment shader invocation.

README.md

@@ -7,7 +7,7 @@ yuzu is an experimental open-source emulator for the Nintendo Switch from the cr
 
 It is written in C++ with portability in mind, with builds actively maintained for Windows, Linux and macOS. The emulator is currently only useful for homebrew development and research purposes.
 
-yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. yuzu can boot some games, to varying degrees of success.
+yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu cannot play any commercial games without major problems. yuzu can boot some games, to varying degrees of success.
 
 yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 

src/audio_core/stream.cpp

@@ -57,9 +57,7 @@ Stream::State Stream::GetState() const {
 
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
     const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
-    const auto us =
-        std::chrono::microseconds((static_cast<u64>(num_samples) * 1000000) / sample_rate);
-    return Core::Timing::usToCycles(us);
+    return Core::Timing::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
 }
 
 static void VolumeAdjustSamples(std::vector<s16>& samples) {

src/common/CMakeLists.txt

@@ -123,8 +123,6 @@ add_library(common STATIC
     timer.h
     uint128.cpp
     uint128.h
-    uuid.cpp
-    uuid.h
     vector_math.h
     web_result.h
     zstd_compression.cpp

src/common/math_util.h

@@ -41,7 +41,4 @@ struct Rectangle {
     }
 };
 
-template <typename T>
-Rectangle(T, T, T, T)->Rectangle<T>;
-
 } // namespace Common

src/common/uuid.cpp

@@ -1,33 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <random>
-
-#include <fmt/format.h>
-
-#include "common/uuid.h"
-
-namespace Common {
-
-UUID UUID::Generate() {
-    std::random_device device;
-    std::mt19937 gen(device());
-    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-    return UUID{distribution(gen), distribution(gen)};
-}
-
-std::string UUID::Format() const {
-    return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
-}
-
-std::string UUID::FormatSwitch() const {
-    std::array<u8, 16> s{};
-    std::memcpy(s.data(), uuid.data(), sizeof(u128));
-    return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
-                       ":02x}{:02x}{:02x}{:02x}{:02x}",
-                       s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
-                       s[12], s[13], s[14], s[15]);
-}
-
-} // namespace Common

src/common/uuid.h

@@ -1,48 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-
-#include "common/common_types.h"
-
-namespace Common {
-
-constexpr u128 INVALID_UUID{{0, 0}};
-
-struct UUID {
-    // UUIDs which are 0 are considered invalid!
-    u128 uuid = INVALID_UUID;
-    constexpr UUID() = default;
-    constexpr explicit UUID(const u128& id) : uuid{id} {}
-    constexpr explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
-
-    constexpr explicit operator bool() const {
-        return uuid[0] != INVALID_UUID[0] && uuid[1] != INVALID_UUID[1];
-    }
-
-    constexpr bool operator==(const UUID& rhs) const {
-        // TODO(DarkLordZach): Replace with uuid == rhs.uuid with C++20
-        return uuid[0] == rhs.uuid[0] && uuid[1] == rhs.uuid[1];
-    }
-
-    constexpr bool operator!=(const UUID& rhs) const {
-        return !operator==(rhs);
-    }
-
-    // TODO(ogniK): Properly generate uuids based on RFC-4122
-    static UUID Generate();
-
-    // Set the UUID to {0,0} to be considered an invalid user
-    constexpr void Invalidate() {
-        uuid = INVALID_UUID;
-    }
-
-    std::string Format() const;
-    std::string FormatSwitch() const;
-};
-static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
-
-} // namespace Common

src/core/CMakeLists.txt

@@ -310,8 +310,6 @@ add_library(core STATIC
     hle/service/mig/mig.h
     hle/service/mii/mii.cpp
     hle/service/mii/mii.h
-    hle/service/mii/mii_manager.cpp
-    hle/service/mii/mii_manager.h
     hle/service/mm/mm_u.cpp
     hle/service/mm/mm_u.h
     hle/service/ncm/ncm.cpp
@@ -328,9 +326,6 @@ add_library(core STATIC
     hle/service/nim/nim.h
     hle/service/npns/npns.cpp
     hle/service/npns/npns.h
-    hle/service/ns/errors.h
-    hle/service/ns/language.cpp
-    hle/service/ns/language.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp

src/core/core.cpp

@@ -18,6 +18,11 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
+#include "core/frontend/applets/error.h"
+#include "core/frontend/applets/general_frontend.h"
+#include "core/frontend/applets/profile_select.h"
+#include "core/frontend/applets/software_keyboard.h"
+#include "core/frontend/applets/web_browser.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
@@ -32,6 +37,9 @@
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "file_sys/cheat_engine.h"
+#include "frontend/applets/profile_select.h"
+#include "frontend/applets/software_keyboard.h"
+#include "frontend/applets/web_browser.h"
 #include "video_core/debug_utils/debug_utils.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
@@ -136,10 +144,20 @@ struct System::Impl {
     ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
                       const std::string& filepath) {
         app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
+
         if (!app_loader) {
             LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
             return ResultStatus::ErrorGetLoader;
         }
+        std::pair<std::optional<u32>, Loader::ResultStatus> system_mode =
+            app_loader->LoadKernelSystemMode();
+
+        if (system_mode.second != Loader::ResultStatus::Success) {
+            LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
+                         static_cast<int>(system_mode.second));
+
+            return ResultStatus::ErrorSystemMode;
+        }
 
         ResultStatus init_result{Init(system, emu_window)};
         if (init_result != ResultStatus::Success) {
@@ -149,7 +167,6 @@ struct System::Impl {
             return init_result;
         }
 
-        telemetry_session->AddInitialInfo(*app_loader);
         auto main_process = Kernel::Process::Create(system, "main");
         const auto [load_result, load_parameters] = app_loader->Load(*main_process);
         if (load_result != Loader::ResultStatus::Success) {

src/core/core.h

@@ -98,6 +98,7 @@ public:
         Success,             ///< Succeeded
         ErrorNotInitialized, ///< Error trying to use core prior to initialization
         ErrorGetLoader,      ///< Error finding the correct application loader
+        ErrorSystemMode,     ///< Error determining the system mode
         ErrorSystemFiles,    ///< Error in finding system files
         ErrorSharedFont,     ///< Error in finding shared font
         ErrorVideoCore,      ///< Error in the video core

src/core/core_timing_util.cpp

@@ -13,40 +13,52 @@ namespace Core::Timing {
 
 constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
-s64 msToCycles(std::chrono::milliseconds ms) {
-    if (static_cast<u64>(ms.count() / 1000) > MAX_VALUE_TO_MULTIPLY) {
+s64 usToCycles(s64 us) {
+    if (static_cast<u64>(us / 1000000) > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (static_cast<u64>(ms.count()) > MAX_VALUE_TO_MULTIPLY) {
+    if (static_cast<u64>(us) > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ms.count() / 1000);
+        return BASE_CLOCK_RATE * (us / 1000000);
     }
-    return (BASE_CLOCK_RATE * ms.count()) / 1000;
+    return (BASE_CLOCK_RATE * us) / 1000000;
 }
 
-s64 usToCycles(std::chrono::microseconds us) {
-    if (static_cast<u64>(us.count() / 1000000) > MAX_VALUE_TO_MULTIPLY) {
+s64 usToCycles(u64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (static_cast<u64>(us.count()) > MAX_VALUE_TO_MULTIPLY) {
+    if (us > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (us.count() / 1000000);
+        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
     }
-    return (BASE_CLOCK_RATE * us.count()) / 1000000;
+    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
 }
 
-s64 nsToCycles(std::chrono::nanoseconds ns) {
-    if (static_cast<u64>(ns.count() / 1000000000) > MAX_VALUE_TO_MULTIPLY) {
+s64 nsToCycles(s64 ns) {
+    if (static_cast<u64>(ns / 1000000000) > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (static_cast<u64>(ns.count()) > MAX_VALUE_TO_MULTIPLY) {
+    if (static_cast<u64>(ns) > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ns.count() / 1000000000);
+        return BASE_CLOCK_RATE * (ns / 1000000000);
     }
-    return (BASE_CLOCK_RATE * ns.count()) / 1000000000;
+    return (BASE_CLOCK_RATE * ns) / 1000000000;
+}
+
+s64 nsToCycles(u64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
 }
 
 u64 CpuCyclesToClockCycles(u64 ticks) {

src/core/core_timing_util.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <chrono>
 #include "common/common_types.h"
 
 namespace Core::Timing {
@@ -14,20 +13,53 @@ namespace Core::Timing {
 constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
 constexpr u64 CNTFREQ = 19200000;           // Value from fusee.
 
-s64 msToCycles(std::chrono::milliseconds ms);
-s64 usToCycles(std::chrono::microseconds us);
-s64 nsToCycles(std::chrono::nanoseconds ns);
-
-inline std::chrono::milliseconds CyclesToMs(s64 cycles) {
-    return std::chrono::milliseconds(cycles * 1000 / BASE_CLOCK_RATE);
+inline s64 msToCycles(int ms) {
+    // since ms is int there is no way to overflow
+    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
 }
 
-inline std::chrono::nanoseconds CyclesToNs(s64 cycles) {
-    return std::chrono::nanoseconds(cycles * 1000000000 / BASE_CLOCK_RATE);
+inline s64 msToCycles(float ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
 }
 
-inline std::chrono::microseconds CyclesToUs(s64 cycles) {
-    return std::chrono::microseconds(cycles * 1000000 / BASE_CLOCK_RATE);
+inline s64 msToCycles(double ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
+}
+
+inline s64 usToCycles(float us) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
+}
+
+inline s64 usToCycles(int us) {
+    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
+}
+
+s64 usToCycles(s64 us);
+
+s64 usToCycles(u64 us);
+
+inline s64 nsToCycles(float ns) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
+}
+
+inline s64 nsToCycles(int ns) {
+    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
+}
+
+s64 nsToCycles(s64 ns);
+
+s64 nsToCycles(u64 ns);
+
+inline u64 cyclesToNs(s64 cycles) {
+    return cycles * 1000000000 / BASE_CLOCK_RATE;
+}
+
+inline s64 cyclesToUs(s64 cycles) {
+    return cycles * 1000000 / BASE_CLOCK_RATE;
+}
+
+inline u64 cyclesToMs(s64 cycles) {
+    return cycles * 1000 / BASE_CLOCK_RATE;
 }
 
 u64 CpuCyclesToClockCycles(u64 ticks);

src/core/file_sys/control_metadata.cpp

@@ -87,10 +87,6 @@ u64 NACP::GetDefaultJournalSaveSize() const {
     return raw.user_account_save_data_journal_size;
 }
 
-u32 NACP::GetSupportedLanguages() const {
-    return raw.supported_languages;
-}
-
 std::vector<u8> NACP::GetRawBytes() const {
     std::vector<u8> out(sizeof(RawNACP));
     std::memcpy(out.data(), &raw, sizeof(RawNACP));

src/core/file_sys/control_metadata.h

@@ -109,7 +109,6 @@ public:
     std::string GetVersionString() const;
     u64 GetDefaultNormalSaveSize() const;
     u64 GetDefaultJournalSaveSize() const;
-    u32 GetSupportedLanguages() const;
     std::vector<u8> GetRawBytes() const;
 
 private:

src/core/frontend/applets/profile_select.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "core/frontend/applets/profile_select.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 
 namespace Core::Frontend {
@@ -11,9 +10,9 @@ namespace Core::Frontend {
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
 void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Common::UUID>)> callback) const {
+    std::function<void(std::optional<Service::Account::UUID>)> callback) const {
     Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user).value_or(Common::UUID{}));
+    callback(manager.GetUser(Settings::values.current_user).value_or(Service::Account::UUID{}));
     LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
 }
 

src/core/frontend/applets/profile_select.h

@@ -6,7 +6,7 @@
 
 #include <functional>
 #include <optional>
-#include "common/uuid.h"
+#include "core/hle/service/acc/profile_manager.h"
 
 namespace Core::Frontend {
 
@@ -14,12 +14,14 @@ class ProfileSelectApplet {
 public:
     virtual ~ProfileSelectApplet();
 
-    virtual void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const = 0;
+    virtual void SelectProfile(
+        std::function<void(std::optional<Service::Account::UUID>)> callback) const = 0;
 };
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
-    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
+    void SelectProfile(
+        std::function<void(std::optional<Service::Account::UUID>)> callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/framebuffer_layout.cpp

@@ -20,7 +20,7 @@ static Common::Rectangle<T> MaxRectangle(Common::Rectangle<T> window_area,
                                 static_cast<T>(std::round(scale * screen_aspect_ratio))};
 }
 
-FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
+FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
     ASSERT(width > 0);
     ASSERT(height > 0);
     // The drawing code needs at least somewhat valid values for both screens
@@ -29,23 +29,22 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
 
     const float emulation_aspect_ratio{static_cast<float>(ScreenUndocked::Height) /
                                        ScreenUndocked::Width};
-    const auto window_aspect_ratio = static_cast<float>(height) / width;
+    Common::Rectangle<unsigned> screen_window_area{0, 0, width, height};
+    Common::Rectangle<unsigned> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
 
-    const Common::Rectangle<u32> screen_window_area{0, 0, width, height};
-    Common::Rectangle<u32> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
+    float window_aspect_ratio = static_cast<float>(height) / width;
 
     if (window_aspect_ratio < emulation_aspect_ratio) {
         screen = screen.TranslateX((screen_window_area.GetWidth() - screen.GetWidth()) / 2);
     } else {
         screen = screen.TranslateY((height - screen.GetHeight()) / 2);
     }
-
     res.screen = screen;
     return res;
 }
 
-FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
-    u32 width, height;
+FramebufferLayout FrameLayoutFromResolutionScale(u16 res_scale) {
+    int width, height;
 
     if (Settings::values.use_docked_mode) {
         width = ScreenDocked::WidthDocked * res_scale;

src/core/frontend/framebuffer_layout.h

@@ -8,22 +8,15 @@
 
 namespace Layout {
 
-enum ScreenUndocked : u32 {
-    Width = 1280,
-    Height = 720,
-};
-
-enum ScreenDocked : u32 {
-    WidthDocked = 1920,
-    HeightDocked = 1080,
-};
+enum ScreenUndocked : unsigned { Width = 1280, Height = 720 };
+enum ScreenDocked : unsigned { WidthDocked = 1920, HeightDocked = 1080 };
 
 /// Describes the layout of the window framebuffer
 struct FramebufferLayout {
-    u32 width{ScreenUndocked::Width};
-    u32 height{ScreenUndocked::Height};
+    unsigned width{ScreenUndocked::Width};
+    unsigned height{ScreenUndocked::Height};
 
-    Common::Rectangle<u32> screen;
+    Common::Rectangle<unsigned> screen;
 
     /**
      * Returns the ration of pixel size of the screen, compared to the native size of the undocked
@@ -40,12 +33,12 @@ struct FramebufferLayout {
  * @param height Window framebuffer height in pixels
  * @return Newly created FramebufferLayout object with default screen regions initialized
  */
-FramebufferLayout DefaultFrameLayout(u32 width, u32 height);
+FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height);
 
 /**
  * Convenience method to get frame layout by resolution scale
  * @param res_scale resolution scale factor
  */
-FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale);
+FramebufferLayout FrameLayoutFromResolutionScale(u16 res_scale);
 
 } // namespace Layout

src/core/hle/kernel/thread.cpp

@@ -75,9 +75,9 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
 
     // This function might be called from any thread so we have to be cautious and use the
     // thread-safe version of ScheduleEvent.
-    const s64 cycles = Core::Timing::nsToCycles(std::chrono::nanoseconds{nanoseconds});
     Core::System::GetInstance().CoreTiming().ScheduleEventThreadsafe(
-        cycles, kernel.ThreadWakeupCallbackEventType(), callback_handle);
+        Core::Timing::nsToCycles(nanoseconds), kernel.ThreadWakeupCallbackEventType(),
+        callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {

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

@@ -34,7 +34,7 @@ constexpr std::array<u8, backup_jpeg_size> backup_jpeg{{
     0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
 }};
 
-static std::string GetImagePath(Common::UUID uuid) {
+static std::string GetImagePath(UUID uuid) {
     return FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
            "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
 }
@@ -46,7 +46,7 @@ static constexpr u32 SanitizeJPEGSize(std::size_t size) {
 
 class IProfile final : public ServiceFramework<IProfile> {
 public:
-    explicit IProfile(Common::UUID user_id, ProfileManager& profile_manager)
+    explicit IProfile(UUID user_id, ProfileManager& profile_manager)
         : ServiceFramework("IProfile"), profile_manager(profile_manager), user_id(user_id) {
         static const FunctionInfo functions[] = {
             {0, &IProfile::Get, "Get"},
@@ -131,7 +131,7 @@ private:
     }
 
     const ProfileManager& profile_manager;
-    Common::UUID user_id; ///< The user id this profile refers to.
+    UUID user_id; ///< The user id this profile refers to.
 };
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
@@ -179,7 +179,7 @@ void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
 
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::UUID user_id = rp.PopRaw<Common::UUID>();
+    UUID user_id = rp.PopRaw<UUID>();
     LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 3};
@@ -205,12 +205,12 @@ void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
     LOG_INFO(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(RESULT_SUCCESS);
-    rb.PushRaw<Common::UUID>(profile_manager->GetLastOpenedUser());
+    rb.PushRaw<UUID>(profile_manager->GetLastOpenedUser());
 }
 
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::UUID user_id = rp.PopRaw<Common::UUID>();
+    UUID user_id = rp.PopRaw<UUID>();
     LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -245,15 +245,15 @@ void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContex
     IPC::ResponseBuilder rb{ctx, 6};
     if (profile_manager->GetUserCount() != 1) {
         rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u128>(Common::INVALID_UUID);
+        rb.PushRaw<u128>(INVALID_UUID);
         return;
     }
 
     const auto user_list = profile_manager->GetAllUsers();
     if (std::all_of(user_list.begin(), user_list.end(),
-                    [](const auto& user) { return user.uuid == Common::INVALID_UUID; })) {
+                    [](const auto& user) { return user.uuid == INVALID_UUID; })) {
         rb.Push(ResultCode(-1)); // TODO(ogniK): Find the correct error code
-        rb.PushRaw<u128>(Common::INVALID_UUID);
+        rb.PushRaw<u128>(INVALID_UUID);
         return;
     }
 

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

@@ -13,8 +13,6 @@
 
 namespace Service::Account {
 
-using Common::UUID;
-
 struct UserRaw {
     UUID uuid;
     UUID uuid2;
@@ -37,6 +35,26 @@ constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);
 
 constexpr char ACC_SAVE_AVATORS_BASE_PATH[] = "/system/save/8000000000000010/su/avators/";
 
+UUID UUID::Generate() {
+    std::random_device device;
+    std::mt19937 gen(device());
+    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
+    return UUID{distribution(gen), distribution(gen)};
+}
+
+std::string UUID::Format() const {
+    return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
+}
+
+std::string UUID::FormatSwitch() const {
+    std::array<u8, 16> s{};
+    std::memcpy(s.data(), uuid.data(), sizeof(u128));
+    return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
+                       ":02x}{:02x}{:02x}{:02x}{:02x}",
+                       s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
+                       s[12], s[13], s[14], s[15]);
+}
+
 ProfileManager::ProfileManager() {
     ParseUserSaveFile();
 
@@ -199,7 +217,7 @@ bool ProfileManager::UserExists(UUID uuid) const {
 bool ProfileManager::UserExistsIndex(std::size_t index) const {
     if (index >= MAX_USERS)
         return false;
-    return profiles[index].user_uuid.uuid != Common::INVALID_UUID;
+    return profiles[index].user_uuid.uuid != INVALID_UUID;
 }
 
 /// Opens a specific user
@@ -293,7 +311,7 @@ bool ProfileManager::RemoveUser(UUID uuid) {
 
 bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
     const auto index = GetUserIndex(uuid);
-    if (!index || profile_new.user_uuid == UUID(Common::INVALID_UUID)) {
+    if (!index || profile_new.user_uuid == UUID(INVALID_UUID)) {
         return false;
     }
 
@@ -324,7 +342,7 @@ void ProfileManager::ParseUserSaveFile() {
     }
 
     for (const auto& user : data.users) {
-        if (user.uuid == UUID(Common::INVALID_UUID)) {
+        if (user.uuid == UUID(INVALID_UUID)) {
             continue;
         }
 

src/core/hle/service/acc/profile_manager.h

@@ -9,15 +9,47 @@
 
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "common/uuid.h"
 #include "core/hle/result.h"
 
 namespace Service::Account {
 constexpr std::size_t MAX_USERS = 8;
+constexpr u128 INVALID_UUID{{0, 0}};
+
+struct UUID {
+    // UUIDs which are 0 are considered invalid!
+    u128 uuid = INVALID_UUID;
+    UUID() = default;
+    explicit UUID(const u128& id) : uuid{id} {}
+    explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
+
+    explicit operator bool() const {
+        return uuid != INVALID_UUID;
+    }
+
+    bool operator==(const UUID& rhs) const {
+        return uuid == rhs.uuid;
+    }
+
+    bool operator!=(const UUID& rhs) const {
+        return !operator==(rhs);
+    }
+
+    // TODO(ogniK): Properly generate uuids based on RFC-4122
+    static UUID Generate();
+
+    // Set the UUID to {0,0} to be considered an invalid user
+    void Invalidate() {
+        uuid = INVALID_UUID;
+    }
+
+    std::string Format() const;
+    std::string FormatSwitch() const;
+};
+static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
 
 constexpr std::size_t profile_username_size = 32;
 using ProfileUsername = std::array<u8, profile_username_size>;
-using UserIDArray = std::array<Common::UUID, MAX_USERS>;
+using UserIDArray = std::array<UUID, MAX_USERS>;
 
 /// Contains extra data related to a user.
 /// TODO: RE this structure
@@ -34,7 +66,7 @@ static_assert(sizeof(ProfileData) == 0x80, "ProfileData structure has incorrect
 /// This holds general information about a users profile. This is where we store all the information
 /// based on a specific user
 struct ProfileInfo {
-    Common::UUID user_uuid;
+    UUID user_uuid;
     ProfileUsername username;
     u64 creation_time;
     ProfileData data; // TODO(ognik): Work out what this is
@@ -42,7 +74,7 @@ struct ProfileInfo {
 };
 
 struct ProfileBase {
-    Common::UUID user_uuid;
+    UUID user_uuid;
     u64_le timestamp;
     ProfileUsername username;
 
@@ -64,33 +96,33 @@ public:
     ~ProfileManager();
 
     ResultCode AddUser(const ProfileInfo& user);
-    ResultCode CreateNewUser(Common::UUID uuid, const ProfileUsername& username);
-    ResultCode CreateNewUser(Common::UUID uuid, const std::string& username);
-    std::optional<Common::UUID> GetUser(std::size_t index) const;
-    std::optional<std::size_t> GetUserIndex(const Common::UUID& uuid) const;
+    ResultCode CreateNewUser(UUID uuid, const ProfileUsername& username);
+    ResultCode CreateNewUser(UUID uuid, const std::string& username);
+    std::optional<UUID> GetUser(std::size_t index) const;
+    std::optional<std::size_t> GetUserIndex(const UUID& uuid) const;
     std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
     bool GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const;
-    bool GetProfileBase(Common::UUID uuid, ProfileBase& profile) const;
+    bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
     bool GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const;
     bool GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
                                ProfileData& data) const;
-    bool GetProfileBaseAndData(Common::UUID uuid, ProfileBase& profile, ProfileData& data) const;
+    bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile, ProfileData& data) const;
     bool GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
                                ProfileData& data) const;
     std::size_t GetUserCount() const;
     std::size_t GetOpenUserCount() const;
-    bool UserExists(Common::UUID uuid) const;
+    bool UserExists(UUID uuid) const;
     bool UserExistsIndex(std::size_t index) const;
-    void OpenUser(Common::UUID uuid);
-    void CloseUser(Common::UUID uuid);
+    void OpenUser(UUID uuid);
+    void CloseUser(UUID uuid);
     UserIDArray GetOpenUsers() const;
     UserIDArray GetAllUsers() const;
-    Common::UUID GetLastOpenedUser() const;
+    UUID GetLastOpenedUser() const;
 
     bool CanSystemRegisterUser() const;
 
-    bool RemoveUser(Common::UUID uuid);
-    bool SetProfileBase(Common::UUID uuid, const ProfileBase& profile_new);
+    bool RemoveUser(UUID uuid);
+    bool SetProfileBase(UUID uuid, const ProfileBase& profile_new);
 
 private:
     void ParseUserSaveFile();
@@ -100,7 +132,7 @@ private:
 
     std::array<ProfileInfo, MAX_USERS> profiles{};
     std::size_t user_count = 0;
-    Common::UUID last_opened_user{Common::INVALID_UUID};
+    UUID last_opened_user{INVALID_UUID};
 };
 
 }; // namespace Service::Account

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

@@ -8,8 +8,6 @@
 #include <cstring>
 #include "audio_core/audio_renderer.h"
 #include "core/core.h"
-#include "core/file_sys/control_metadata.h"
-#include "core/file_sys/patch_manager.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/kernel.h"
@@ -31,11 +29,9 @@
 #include "core/hle/service/am/tcap.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/set/set.h"
-#include "core/hle/service/sm/sm.h"
 #include "core/hle/service/vi/vi.h"
 #include "core/settings.h"
 
@@ -1104,42 +1100,10 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
     // TODO(bunnei): This should be configurable
     LOG_DEBUG(Service_AM, "called");
 
-    // Get supported languages from NACP, if possible
-    // Default to 0 (all languages supported)
-    u32 supported_languages = 0;
-    FileSys::PatchManager pm{Core::System::GetInstance().CurrentProcess()->GetTitleID()};
-
-    const auto res = pm.GetControlMetadata();
-    if (res.first != nullptr) {
-        supported_languages = res.first->GetSupportedLanguages();
-    }
-
-    // Call IApplicationManagerInterface implementation.
-    auto& service_manager = Core::System::GetInstance().ServiceManager();
-    auto ns_am2 = service_manager.GetService<Service::NS::NS>("ns:am2");
-    auto app_man = ns_am2->GetApplicationManagerInterface();
-
-    // Get desired application language
-    const auto res_lang = app_man->GetApplicationDesiredLanguage(supported_languages);
-    if (res_lang.Failed()) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res_lang.Code());
-        return;
-    }
-
-    // Convert to settings language code.
-    const auto res_code = app_man->ConvertApplicationLanguageToLanguageCode(*res_lang);
-    if (res_code.Failed()) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res_code.Code());
-        return;
-    }
-
-    LOG_DEBUG(Service_AM, "got desired_language={:016X}", *res_code);
-
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(*res_code);
+    rb.Push(
+        static_cast<u64>(Service::Set::GetLanguageCodeFromIndex(Settings::values.language_index)));
 }
 
 void IApplicationFunctions::InitializeGamePlayRecording(Kernel::HLERequestContext& ctx) {

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

@@ -121,21 +121,6 @@ void Applet::Initialize() {
     initialized = true;
 }
 
-AppletFrontendSet::AppletFrontendSet() = default;
-
-AppletFrontendSet::AppletFrontendSet(ErrorApplet error, PhotoViewer photo_viewer,
-                                     ProfileSelect profile_select,
-                                     SoftwareKeyboard software_keyboard, WebBrowser web_browser)
-    : error{std::move(error)}, photo_viewer{std::move(photo_viewer)}, profile_select{std::move(
-                                                                          profile_select)},
-      software_keyboard{std::move(software_keyboard)}, web_browser{std::move(web_browser)} {}
-
-AppletFrontendSet::~AppletFrontendSet() = default;
-
-AppletFrontendSet::AppletFrontendSet(AppletFrontendSet&&) noexcept = default;
-
-AppletFrontendSet& AppletFrontendSet::operator=(AppletFrontendSet&&) noexcept = default;
-
 AppletManager::AppletManager() = default;
 
 AppletManager::~AppletManager() = default;

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

@@ -137,28 +137,11 @@ protected:
 };
 
 struct AppletFrontendSet {
-    using ErrorApplet = std::unique_ptr<Core::Frontend::ErrorApplet>;
-    using PhotoViewer = std::unique_ptr<Core::Frontend::PhotoViewerApplet>;
-    using ProfileSelect = std::unique_ptr<Core::Frontend::ProfileSelectApplet>;
-    using SoftwareKeyboard = std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet>;
-    using WebBrowser = std::unique_ptr<Core::Frontend::WebBrowserApplet>;
-
-    AppletFrontendSet();
-    AppletFrontendSet(ErrorApplet error, PhotoViewer photo_viewer, ProfileSelect profile_select,
-                      SoftwareKeyboard software_keyboard, WebBrowser web_browser);
-    ~AppletFrontendSet();
-
-    AppletFrontendSet(const AppletFrontendSet&) = delete;
-    AppletFrontendSet& operator=(const AppletFrontendSet&) = delete;
-
-    AppletFrontendSet(AppletFrontendSet&&) noexcept;
-    AppletFrontendSet& operator=(AppletFrontendSet&&) noexcept;
-
-    ErrorApplet error;
-    PhotoViewer photo_viewer;
-    ProfileSelect profile_select;
-    SoftwareKeyboard software_keyboard;
-    WebBrowser web_browser;
+    std::unique_ptr<Core::Frontend::ErrorApplet> error;
+    std::unique_ptr<Core::Frontend::PhotoViewerApplet> photo_viewer;
+    std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_select;
+    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
+    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;
 };
 
 class AppletManager {

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

@@ -53,19 +53,19 @@ void ProfileSelect::Execute() {
         return;
     }
 
-    frontend.SelectProfile([this](std::optional<Common::UUID> uuid) { SelectionComplete(uuid); });
+    frontend.SelectProfile([this](std::optional<Account::UUID> uuid) { SelectionComplete(uuid); });
 }
 
-void ProfileSelect::SelectionComplete(std::optional<Common::UUID> uuid) {
+void ProfileSelect::SelectionComplete(std::optional<Account::UUID> uuid) {
     UserSelectionOutput output{};
 
-    if (uuid.has_value() && uuid->uuid != Common::INVALID_UUID) {
+    if (uuid.has_value() && uuid->uuid != Account::INVALID_UUID) {
         output.result = 0;
         output.uuid_selected = uuid->uuid;
     } else {
         status = ERR_USER_CANCELLED_SELECTION;
         output.result = ERR_USER_CANCELLED_SELECTION.raw;
-        output.uuid_selected = Common::INVALID_UUID;
+        output.uuid_selected = Account::INVALID_UUID;
     }
 
     final_data = std::vector<u8>(sizeof(UserSelectionOutput));

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

@@ -7,8 +7,7 @@
 #include <vector>
 
 #include "common/common_funcs.h"
-#include "common/uuid.h"
-#include "core/hle/result.h"
+#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/applets/applets.h"
 
 namespace Service::AM::Applets {
@@ -39,7 +38,7 @@ public:
     void ExecuteInteractive() override;
     void Execute() override;
 
-    void SelectionComplete(std::optional<Common::UUID> uuid);
+    void SelectionComplete(std::optional<Account::UUID> uuid);
 
 private:
     const Core::Frontend::ProfileSelectApplet& frontend;

src/core/hle/service/mii/mii.cpp

@@ -4,50 +4,42 @@
 
 #include <memory>
 
-#include <fmt/ostream.h>
-
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/mii/mii.h"
-#include "core/hle/service/mii/mii_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::Mii {
 
-constexpr ResultCode ERROR_INVALID_ARGUMENT{ErrorModule::Mii, 1};
-constexpr ResultCode ERROR_CANNOT_FIND_ENTRY{ErrorModule::Mii, 4};
-constexpr ResultCode ERROR_NOT_IN_TEST_MODE{ErrorModule::Mii, 99};
-
 class IDatabaseService final : public ServiceFramework<IDatabaseService> {
 public:
     explicit IDatabaseService() : ServiceFramework{"IDatabaseService"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &IDatabaseService::IsUpdated, "IsUpdated"},
-            {1, &IDatabaseService::IsFullDatabase, "IsFullDatabase"},
-            {2, &IDatabaseService::GetCount, "GetCount"},
-            {3, &IDatabaseService::Get, "Get"},
-            {4, &IDatabaseService::Get1, "Get1"},
+            {0, nullptr, "IsUpdated"},
+            {1, nullptr, "IsFullDatabase"},
+            {2, nullptr, "GetCount"},
+            {3, nullptr, "Get"},
+            {4, nullptr, "Get1"},
             {5, nullptr, "UpdateLatest"},
-            {6, &IDatabaseService::BuildRandom, "BuildRandom"},
-            {7, &IDatabaseService::BuildDefault, "BuildDefault"},
-            {8, &IDatabaseService::Get2, "Get2"},
-            {9, &IDatabaseService::Get3, "Get3"},
+            {6, nullptr, "BuildRandom"},
+            {7, nullptr, "BuildDefault"},
+            {8, nullptr, "Get2"},
+            {9, nullptr, "Get3"},
             {10, nullptr, "UpdateLatest1"},
-            {11, &IDatabaseService::FindIndex, "FindIndex"},
-            {12, &IDatabaseService::Move, "Move"},
-            {13, &IDatabaseService::AddOrReplace, "AddOrReplace"},
-            {14, &IDatabaseService::Delete, "Delete"},
-            {15, &IDatabaseService::DestroyFile, "DestroyFile"},
-            {16, &IDatabaseService::DeleteFile, "DeleteFile"},
-            {17, &IDatabaseService::Format, "Format"},
+            {11, nullptr, "FindIndex"},
+            {12, nullptr, "Move"},
+            {13, nullptr, "AddOrReplace"},
+            {14, nullptr, "Delete"},
+            {15, nullptr, "DestroyFile"},
+            {16, nullptr, "DeleteFile"},
+            {17, nullptr, "Format"},
             {18, nullptr, "Import"},
             {19, nullptr, "Export"},
             {20, nullptr, "IsBrokenDatabaseWithClearFlag"},
-            {21, &IDatabaseService::GetIndex, "GetIndex"},
+            {21, nullptr, "GetIndex"},
             {22, nullptr, "SetInterfaceVersion"},
             {23, nullptr, "Convert"},
         };
@@ -55,305 +47,6 @@ public:
 
         RegisterHandlers(functions);
     }
-
-private:
-    template <typename OutType>
-    std::vector<u8> SerializeArray(OutType (MiiManager::*getter)(u32) const, u32 offset,
-                                   u32 requested_size, u32& read_size) {
-        read_size = std::min(requested_size, db.Size() - offset);
-
-        std::vector<u8> out(read_size * sizeof(OutType));
-
-        for (u32 i = 0; i < read_size; ++i) {
-            const auto obj = (db.*getter)(offset + i);
-            std::memcpy(out.data() + i * sizeof(OutType), &obj, sizeof(OutType));
-        }
-
-        return out;
-    }
-
-    void IsUpdated(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto source{rp.PopRaw<Source>()};
-
-        LOG_DEBUG(Service_Mii, "called with source={}", source);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(db.CheckUpdatedFlag());
-        db.ResetUpdatedFlag();
-    }
-
-    void IsFullDatabase(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Mii, "called");
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(db.Full());
-    }
-
-    void GetCount(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto source{rp.PopRaw<Source>()};
-
-        LOG_DEBUG(Service_Mii, "called with source={}", source);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(db.Size());
-    }
-
-    // Gets Miis from database at offset and index in format MiiInfoElement
-    void Get(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto size{rp.PopRaw<u32>()};
-        const auto source{rp.PopRaw<Source>()};
-
-        LOG_DEBUG(Service_Mii, "called with size={:08X}, offset={:08X}, source={}", size,
-                  offsets[0], source);
-
-        u32 read_size{};
-        ctx.WriteBuffer(SerializeArray(&MiiManager::GetInfoElement, offsets[0], size, read_size));
-        offsets[0] += read_size;
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(read_size);
-    }
-
-    // Gets Miis from database at offset and index in format MiiInfo
-    void Get1(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto size{rp.PopRaw<u32>()};
-        const auto source{rp.PopRaw<Source>()};
-
-        LOG_DEBUG(Service_Mii, "called with size={:08X}, offset={:08X}, source={}", size,
-                  offsets[1], source);
-
-        u32 read_size{};
-        ctx.WriteBuffer(SerializeArray(&MiiManager::GetInfo, offsets[1], size, read_size));
-        offsets[1] += read_size;
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(read_size);
-    }
-
-    void BuildRandom(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto [unknown1, unknown2, unknown3] = rp.PopRaw<RandomParameters>();
-
-        if (unknown1 > 3) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            LOG_ERROR(Service_Mii, "Invalid unknown1 value: {}", unknown1);
-            return;
-        }
-
-        if (unknown2 > 2) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            LOG_ERROR(Service_Mii, "Invalid unknown2 value: {}", unknown2);
-            return;
-        }
-
-        if (unknown3 > 3) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            LOG_ERROR(Service_Mii, "Invalid unknown3 value: {}", unknown3);
-            return;
-        }
-
-        LOG_DEBUG(Service_Mii, "called with param_1={:08X}, param_2={:08X}, param_3={:08X}",
-                  unknown1, unknown2, unknown3);
-
-        const auto info = db.CreateRandom({unknown1, unknown2, unknown3});
-        IPC::ResponseBuilder rb{ctx, 2 + sizeof(MiiInfo) / sizeof(u32)};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<MiiInfo>(info);
-    }
-
-    void BuildDefault(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto index{rp.PopRaw<u32>()};
-
-        if (index > 5) {
-            LOG_ERROR(Service_Mii, "invalid argument, index cannot be greater than 5 but is {:08X}",
-                      index);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            return;
-        }
-
-        LOG_DEBUG(Service_Mii, "called with index={:08X}", index);
-
-        const auto info = db.CreateDefault(index);
-        IPC::ResponseBuilder rb{ctx, 2 + sizeof(MiiInfo) / sizeof(u32)};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<MiiInfo>(info);
-    }
-
-    // Gets Miis from database at offset and index in format MiiStoreDataElement
-    void Get2(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto size{rp.PopRaw<u32>()};
-        const auto source{rp.PopRaw<Source>()};
-
-        LOG_DEBUG(Service_Mii, "called with size={:08X}, offset={:08X}, source={}", size,
-                  offsets[2], source);
-
-        u32 read_size{};
-        ctx.WriteBuffer(
-            SerializeArray(&MiiManager::GetStoreDataElement, offsets[2], size, read_size));
-        offsets[2] += read_size;
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(read_size);
-    }
-
-    // Gets Miis from database at offset and index in format MiiStoreData
-    void Get3(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto size{rp.PopRaw<u32>()};
-        const auto source{rp.PopRaw<Source>()};
-
-        LOG_DEBUG(Service_Mii, "called with size={:08X}, offset={:08X}, source={}", size,
-                  offsets[3], source);
-
-        u32 read_size{};
-        ctx.WriteBuffer(SerializeArray(&MiiManager::GetStoreData, offsets[3], size, read_size));
-        offsets[3] += read_size;
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(read_size);
-    }
-
-    void FindIndex(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto uuid{rp.PopRaw<Common::UUID>()};
-        const auto unknown{rp.PopRaw<bool>()};
-
-        LOG_DEBUG(Service_Mii, "called with uuid={}, unknown={}", uuid.FormatSwitch(), unknown);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-
-        const auto index = db.IndexOf(uuid);
-        if (index > MAX_MIIS) {
-            // TODO(DarkLordZach): Find a better error code
-            rb.Push(ResultCode(-1));
-            rb.Push(index);
-        } else {
-            rb.Push(RESULT_SUCCESS);
-            rb.Push(index);
-        }
-    }
-
-    void Move(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto uuid{rp.PopRaw<Common::UUID>()};
-        const auto index{rp.PopRaw<s32>()};
-
-        if (index < 0) {
-            LOG_ERROR(Service_Mii, "Index cannot be negative but is {:08X}!", index);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            return;
-        }
-
-        LOG_DEBUG(Service_Mii, "called with uuid={}, index={:08X}", uuid.FormatSwitch(), index);
-
-        const auto success = db.Move(uuid, index);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        // TODO(DarkLordZach): Find a better error code
-        rb.Push(success ? RESULT_SUCCESS : ResultCode(-1));
-    }
-
-    void AddOrReplace(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto data{rp.PopRaw<MiiStoreData>()};
-
-        LOG_DEBUG(Service_Mii, "called with Mii data uuid={}, name={}", data.uuid.FormatSwitch(),
-                  Common::UTF16ToUTF8(data.Name()));
-
-        const auto success = db.AddOrReplace(data);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        // TODO(DarkLordZach): Find a better error code
-        rb.Push(success ? RESULT_SUCCESS : ResultCode(-1));
-    }
-
-    void Delete(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto uuid{rp.PopRaw<Common::UUID>()};
-
-        LOG_DEBUG(Service_Mii, "called with uuid={}", uuid.FormatSwitch());
-
-        const auto success = db.Remove(uuid);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(success ? RESULT_SUCCESS : ERROR_CANNOT_FIND_ENTRY);
-    }
-
-    void DestroyFile(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Mii, "called");
-
-        if (!db.IsTestModeEnabled()) {
-            LOG_ERROR(Service_Mii, "Database is not in test mode -- cannot destory database file.");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_NOT_IN_TEST_MODE);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(db.DestroyFile());
-    }
-
-    void DeleteFile(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Mii, "called");
-
-        if (!db.IsTestModeEnabled()) {
-            LOG_ERROR(Service_Mii, "Database is not in test mode -- cannot delete database file.");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_NOT_IN_TEST_MODE);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(db.DeleteFile());
-    }
-
-    void Format(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Mii, "called");
-
-        db.Clear();
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void GetIndex(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto info{rp.PopRaw<MiiInfo>()};
-
-        LOG_DEBUG(Service_Mii, "called with Mii info uuid={}, name={}", info.uuid.FormatSwitch(),
-                  Common::UTF16ToUTF8(info.Name()));
-
-        const auto index = db.IndexOf(info);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(index);
-    }
-
-    MiiManager db;
-
-    // Last read offsets of Get functions
-    std::array<u32, 4> offsets{};
 };
 
 class MiiDBModule final : public ServiceFramework<MiiDBModule> {

src/core/hle/service/mii/mii_manager.cpp

@@ -1,416 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstring>
-#include "common/assert.h"
-#include "common/file_util.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/hle/service/mii/mii_manager.h"
-
-namespace Service::Mii {
-
-namespace {
-
-constexpr char MII_SAVE_DATABASE_PATH[] = "/system/save/8000000000000030/MiiDatabase.dat";
-constexpr std::array<char16_t, 11> DEFAULT_MII_NAME = {u'y', u'u', u'z', u'u', u'\0'};
-
-// This value was retrieved from HW test
-constexpr MiiStoreData DEFAULT_MII = {
-    {
-        0x21, 0x40, 0x40, 0x01, 0x08, 0x01, 0x13, 0x08, 0x08, 0x02, 0x17, 0x8C, 0x06, 0x01,
-        0x69, 0x6D, 0x8A, 0x6A, 0x82, 0x14, 0x00, 0x00, 0x00, 0x20, 0x64, 0x72, 0x44, 0x44,
-    },
-    {'y', 'u', 'z', 'u', '\0'},
-    Common::UUID{1, 0},
-    0,
-    0,
-};
-
-// Default values taken from multiple real databases
-const MiiDatabase DEFAULT_MII_DATABASE{Common::MakeMagic('N', 'F', 'D', 'B'), {}, {1}, 0, 0};
-
-constexpr std::array<const char*, 4> SOURCE_NAMES{
-    "Database",
-    "Default",
-    "Account",
-    "Friend",
-};
-
-template <typename T, std::size_t SourceArraySize, std::size_t DestArraySize>
-std::array<T, DestArraySize> ResizeArray(const std::array<T, SourceArraySize>& in) {
-    std::array<T, DestArraySize> out{};
-    std::memcpy(out.data(), in.data(), sizeof(T) * std::min(SourceArraySize, DestArraySize));
-    return out;
-}
-
-MiiInfo ConvertStoreDataToInfo(const MiiStoreData& data) {
-    MiiStoreBitFields bf{};
-    std::memcpy(&bf, data.data.data(), sizeof(MiiStoreBitFields));
-    return {
-        data.uuid,
-        ResizeArray<char16_t, 10, 11>(data.name),
-        static_cast<u8>(bf.font_region.Value()),
-        static_cast<u8>(bf.favorite_color.Value()),
-        static_cast<u8>(bf.gender.Value()),
-        static_cast<u8>(bf.height.Value()),
-        static_cast<u8>(bf.weight.Value()),
-        static_cast<u8>(bf.mii_type.Value()),
-        static_cast<u8>(bf.mii_region.Value()),
-        static_cast<u8>(bf.face_type.Value()),
-        static_cast<u8>(bf.face_color.Value()),
-        static_cast<u8>(bf.face_wrinkle.Value()),
-        static_cast<u8>(bf.face_makeup.Value()),
-        static_cast<u8>(bf.hair_type.Value()),
-        static_cast<u8>(bf.hair_color.Value()),
-        static_cast<bool>(bf.hair_flip.Value()),
-        static_cast<u8>(bf.eye_type.Value()),
-        static_cast<u8>(bf.eye_color.Value()),
-        static_cast<u8>(bf.eye_scale.Value()),
-        static_cast<u8>(bf.eye_aspect.Value()),
-        static_cast<u8>(bf.eye_rotate.Value()),
-        static_cast<u8>(bf.eye_x.Value()),
-        static_cast<u8>(bf.eye_y.Value()),
-        static_cast<u8>(bf.eyebrow_type.Value()),
-        static_cast<u8>(bf.eyebrow_color.Value()),
-        static_cast<u8>(bf.eyebrow_scale.Value()),
-        static_cast<u8>(bf.eyebrow_aspect.Value()),
-        static_cast<u8>(bf.eyebrow_rotate.Value()),
-        static_cast<u8>(bf.eyebrow_x.Value()),
-        static_cast<u8>(bf.eyebrow_y.Value()),
-        static_cast<u8>(bf.nose_type.Value()),
-        static_cast<u8>(bf.nose_scale.Value()),
-        static_cast<u8>(bf.nose_y.Value()),
-        static_cast<u8>(bf.mouth_type.Value()),
-        static_cast<u8>(bf.mouth_color.Value()),
-        static_cast<u8>(bf.mouth_scale.Value()),
-        static_cast<u8>(bf.mouth_aspect.Value()),
-        static_cast<u8>(bf.mouth_y.Value()),
-        static_cast<u8>(bf.facial_hair_color.Value()),
-        static_cast<u8>(bf.beard_type.Value()),
-        static_cast<u8>(bf.mustache_type.Value()),
-        static_cast<u8>(bf.mustache_scale.Value()),
-        static_cast<u8>(bf.mustache_y.Value()),
-        static_cast<u8>(bf.glasses_type.Value()),
-        static_cast<u8>(bf.glasses_color.Value()),
-        static_cast<u8>(bf.glasses_scale.Value()),
-        static_cast<u8>(bf.glasses_y.Value()),
-        static_cast<u8>(bf.mole_type.Value()),
-        static_cast<u8>(bf.mole_scale.Value()),
-        static_cast<u8>(bf.mole_x.Value()),
-        static_cast<u8>(bf.mole_y.Value()),
-        0x00,
-    };
-}
-MiiStoreData ConvertInfoToStoreData(const MiiInfo& info) {
-    MiiStoreData out{};
-    out.name = ResizeArray<char16_t, 11, 10>(info.name);
-    out.uuid = info.uuid;
-
-    MiiStoreBitFields bf{};
-
-    bf.hair_type.Assign(info.hair_type);
-    bf.mole_type.Assign(info.mole_type);
-    bf.height.Assign(info.height);
-    bf.hair_flip.Assign(info.hair_flip);
-    bf.weight.Assign(info.weight);
-    bf.hair_color.Assign(info.hair_color);
-
-    bf.gender.Assign(info.gender);
-    bf.eye_color.Assign(info.eye_color);
-    bf.eyebrow_color.Assign(info.eyebrow_color);
-    bf.mouth_color.Assign(info.mouth_color);
-    bf.facial_hair_color.Assign(info.facial_hair_color);
-
-    bf.mii_type.Assign(info.mii_type);
-    bf.glasses_color.Assign(info.glasses_color);
-    bf.font_region.Assign(info.font_region);
-    bf.eye_type.Assign(info.eye_type);
-    bf.mii_region.Assign(info.mii_region);
-    bf.mouth_type.Assign(info.mouth_type);
-    bf.glasses_scale.Assign(info.glasses_scale);
-    bf.eye_y.Assign(info.eye_y);
-
-    bf.mustache_type.Assign(info.mustache_type);
-    bf.eyebrow_type.Assign(info.eyebrow_type);
-    bf.beard_type.Assign(info.beard_type);
-    bf.nose_type.Assign(info.nose_type);
-    bf.mouth_aspect.Assign(info.mouth_aspect_ratio);
-    bf.nose_y.Assign(info.nose_y);
-    bf.eyebrow_aspect.Assign(info.eyebrow_aspect_ratio);
-    bf.mouth_y.Assign(info.mouth_y);
-
-    bf.eye_rotate.Assign(info.eye_rotate);
-    bf.mustache_y.Assign(info.mustache_y);
-    bf.eye_aspect.Assign(info.eye_aspect_ratio);
-    bf.glasses_y.Assign(info.glasses_y);
-    bf.eye_scale.Assign(info.eye_scale);
-    bf.mole_x.Assign(info.mole_x);
-    bf.mole_y.Assign(info.mole_y);
-
-    bf.glasses_type.Assign(info.glasses_type);
-    bf.face_type.Assign(info.face_type);
-    bf.favorite_color.Assign(info.favorite_color);
-    bf.face_wrinkle.Assign(info.face_wrinkle);
-    bf.face_color.Assign(info.face_color);
-    bf.eye_x.Assign(info.eye_x);
-    bf.face_makeup.Assign(info.face_makeup);
-
-    bf.eyebrow_rotate.Assign(info.eyebrow_rotate);
-    bf.eyebrow_scale.Assign(info.eyebrow_scale);
-    bf.eyebrow_y.Assign(info.eyebrow_y);
-    bf.eyebrow_x.Assign(info.eyebrow_x);
-    bf.mouth_scale.Assign(info.mouth_scale);
-    bf.nose_scale.Assign(info.nose_scale);
-    bf.mole_scale.Assign(info.mole_scale);
-    bf.mustache_scale.Assign(info.mustache_scale);
-
-    std::memcpy(out.data.data(), &bf, sizeof(MiiStoreBitFields));
-
-    return out;
-}
-
-} // namespace
-
-std::ostream& operator<<(std::ostream& os, Source source) {
-    os << SOURCE_NAMES.at(static_cast<std::size_t>(source));
-    return os;
-}
-
-std::u16string MiiInfo::Name() const {
-    return Common::UTF16StringFromFixedZeroTerminatedBuffer(name.data(), name.size());
-}
-
-bool operator==(const MiiInfo& lhs, const MiiInfo& rhs) {
-    return std::memcmp(&lhs, &rhs, sizeof(MiiInfo)) == 0;
-}
-
-bool operator!=(const MiiInfo& lhs, const MiiInfo& rhs) {
-    return !operator==(lhs, rhs);
-}
-
-std::u16string MiiStoreData::Name() const {
-    return Common::UTF16StringFromFixedZeroTerminatedBuffer(name.data(), name.size());
-}
-
-MiiManager::MiiManager() = default;
-
-MiiManager::~MiiManager() = default;
-
-MiiInfo MiiManager::CreateRandom(RandomParameters params) {
-    LOG_WARNING(Service_Mii,
-                "(STUBBED) called with params={:08X}{:08X}{:08X}, returning default Mii",
-                params.unknown_1, params.unknown_2, params.unknown_3);
-
-    return ConvertStoreDataToInfo(CreateMiiWithUniqueUUID());
-}
-
-MiiInfo MiiManager::CreateDefault(u32 index) {
-    const auto new_mii = CreateMiiWithUniqueUUID();
-
-    database.miis.at(index) = new_mii;
-
-    EnsureDatabasePartition();
-    return ConvertStoreDataToInfo(new_mii);
-}
-
-bool MiiManager::CheckUpdatedFlag() const {
-    return updated_flag;
-}
-
-void MiiManager::ResetUpdatedFlag() {
-    updated_flag = false;
-}
-
-bool MiiManager::IsTestModeEnabled() const {
-    return is_test_mode_enabled;
-}
-
-bool MiiManager::Empty() const {
-    return Size() == 0;
-}
-
-bool MiiManager::Full() const {
-    return Size() == MAX_MIIS;
-}
-
-void MiiManager::Clear() {
-    updated_flag = true;
-    std::fill(database.miis.begin(), database.miis.end(), MiiStoreData{});
-}
-
-u32 MiiManager::Size() const {
-    return static_cast<u32>(std::count_if(database.miis.begin(), database.miis.end(),
-                                          [](const MiiStoreData& elem) { return elem.uuid; }));
-}
-
-MiiInfo MiiManager::GetInfo(u32 index) const {
-    return ConvertStoreDataToInfo(GetStoreData(index));
-}
-
-MiiInfoElement MiiManager::GetInfoElement(u32 index) const {
-    return {GetInfo(index), Source::Database};
-}
-
-MiiStoreData MiiManager::GetStoreData(u32 index) const {
-    return database.miis.at(index);
-}
-
-MiiStoreDataElement MiiManager::GetStoreDataElement(u32 index) const {
-    return {GetStoreData(index), Source::Database};
-}
-
-bool MiiManager::Remove(Common::UUID uuid) {
-    const auto iter = std::find_if(database.miis.begin(), database.miis.end(),
-                                   [uuid](const MiiStoreData& elem) { return elem.uuid == uuid; });
-
-    if (iter == database.miis.end())
-        return false;
-
-    updated_flag = true;
-    *iter = MiiStoreData{};
-    EnsureDatabasePartition();
-    return true;
-}
-
-u32 MiiManager::IndexOf(Common::UUID uuid) const {
-    const auto iter = std::find_if(database.miis.begin(), database.miis.end(),
-                                   [uuid](const MiiStoreData& elem) { return elem.uuid == uuid; });
-
-    if (iter == database.miis.end())
-        return INVALID_INDEX;
-
-    return static_cast<u32>(std::distance(database.miis.begin(), iter));
-}
-
-u32 MiiManager::IndexOf(const MiiInfo& info) const {
-    const auto iter =
-        std::find_if(database.miis.begin(), database.miis.end(), [&info](const MiiStoreData& elem) {
-            return ConvertStoreDataToInfo(elem) == info;
-        });
-
-    if (iter == database.miis.end())
-        return INVALID_INDEX;
-
-    return static_cast<u32>(std::distance(database.miis.begin(), iter));
-}
-
-bool MiiManager::Move(Common::UUID uuid, u32 new_index) {
-    const auto index = IndexOf(uuid);
-
-    if (index == INVALID_INDEX || new_index >= MAX_MIIS)
-        return false;
-
-    updated_flag = true;
-    const auto moving = database.miis[index];
-    const auto replacing = database.miis[new_index];
-    if (replacing.uuid) {
-        database.miis[index] = replacing;
-        database.miis[new_index] = moving;
-    } else {
-        database.miis[index] = MiiStoreData{};
-        database.miis[new_index] = moving;
-    }
-
-    EnsureDatabasePartition();
-    return true;
-}
-
-bool MiiManager::AddOrReplace(const MiiStoreData& data) {
-    const auto index = IndexOf(data.uuid);
-
-    updated_flag = true;
-    if (index == INVALID_INDEX) {
-        const auto size = Size();
-        if (size == MAX_MIIS)
-            return false;
-        database.miis[size] = data;
-    } else {
-        database.miis[index] = data;
-    }
-
-    return true;
-}
-
-bool MiiManager::DestroyFile() {
-    database = DEFAULT_MII_DATABASE;
-    updated_flag = false;
-    return DeleteFile();
-}
-
-bool MiiManager::DeleteFile() {
-    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + MII_SAVE_DATABASE_PATH;
-    return FileUtil::Exists(path) && FileUtil::Delete(path);
-}
-
-void MiiManager::WriteToFile() {
-    const auto raw_path =
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000030";
-    if (FileUtil::Exists(raw_path) && !FileUtil::IsDirectory(raw_path))
-        FileUtil::Delete(raw_path);
-
-    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + MII_SAVE_DATABASE_PATH;
-
-    if (!FileUtil::CreateFullPath(path)) {
-        LOG_WARNING(Service_Mii,
-                    "Failed to create full path of MiiDatabase.dat. Create the directory "
-                    "nand/system/save/8000000000000030 to mitigate this "
-                    "issue.");
-        return;
-    }
-
-    FileUtil::IOFile save(path, "wb");
-
-    if (!save.IsOpen()) {
-        LOG_WARNING(Service_Mii, "Failed to write save data to file... No changes to user data "
-                                 "made in current session will be saved.");
-        return;
-    }
-
-    save.Resize(sizeof(MiiDatabase));
-    if (save.WriteBytes(&database, sizeof(MiiDatabase)) != sizeof(MiiDatabase)) {
-        LOG_WARNING(Service_Mii, "Failed to write all data to save file... Data may be malformed "
-                                 "and/or regenerated on next run.");
-        save.Resize(0);
-    }
-}
-
-void MiiManager::ReadFromFile() {
-    FileUtil::IOFile save(
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + MII_SAVE_DATABASE_PATH, "rb");
-
-    if (!save.IsOpen()) {
-        LOG_WARNING(Service_ACC, "Failed to load profile data from save data... Generating new "
-                                 "blank Mii database with no Miis.");
-        std::memcpy(&database, &DEFAULT_MII_DATABASE, sizeof(MiiDatabase));
-        return;
-    }
-
-    if (save.ReadBytes(&database, sizeof(MiiDatabase)) != sizeof(MiiDatabase)) {
-        LOG_WARNING(Service_ACC, "MiiDatabase.dat is smaller than expected... Generating new blank "
-                                 "Mii database with no Miis.");
-        std::memcpy(&database, &DEFAULT_MII_DATABASE, sizeof(MiiDatabase));
-        return;
-    }
-
-    EnsureDatabasePartition();
-}
-
-MiiStoreData MiiManager::CreateMiiWithUniqueUUID() const {
-    auto new_mii = DEFAULT_MII;
-
-    do {
-        new_mii.uuid = Common::UUID::Generate();
-    } while (IndexOf(new_mii.uuid) != INVALID_INDEX);
-
-    return new_mii;
-}
-
-void MiiManager::EnsureDatabasePartition() {
-    std::stable_partition(database.miis.begin(), database.miis.end(),
-                          [](const MiiStoreData& elem) { return elem.uuid; });
-}
-
-} // namespace Service::Mii

src/core/hle/service/mii/mii_manager.h

@@ -1,273 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/bit_field.h"
-#include "common/common_funcs.h"
-#include "common/uuid.h"
-
-namespace Service::Mii {
-
-constexpr std::size_t MAX_MIIS = 100;
-constexpr u32 INVALID_INDEX = 0xFFFFFFFF;
-
-struct RandomParameters {
-    u32 unknown_1;
-    u32 unknown_2;
-    u32 unknown_3;
-};
-static_assert(sizeof(RandomParameters) == 0xC, "RandomParameters has incorrect size.");
-
-enum class Source : u32 {
-    Database = 0,
-    Default = 1,
-    Account = 2,
-    Friend = 3,
-};
-
-std::ostream& operator<<(std::ostream& os, Source source);
-
-struct MiiInfo {
-    Common::UUID uuid;
-    std::array<char16_t, 11> name;
-    u8 font_region;
-    u8 favorite_color;
-    u8 gender;
-    u8 height;
-    u8 weight;
-    u8 mii_type;
-    u8 mii_region;
-    u8 face_type;
-    u8 face_color;
-    u8 face_wrinkle;
-    u8 face_makeup;
-    u8 hair_type;
-    u8 hair_color;
-    bool hair_flip;
-    u8 eye_type;
-    u8 eye_color;
-    u8 eye_scale;
-    u8 eye_aspect_ratio;
-    u8 eye_rotate;
-    u8 eye_x;
-    u8 eye_y;
-    u8 eyebrow_type;
-    u8 eyebrow_color;
-    u8 eyebrow_scale;
-    u8 eyebrow_aspect_ratio;
-    u8 eyebrow_rotate;
-    u8 eyebrow_x;
-    u8 eyebrow_y;
-    u8 nose_type;
-    u8 nose_scale;
-    u8 nose_y;
-    u8 mouth_type;
-    u8 mouth_color;
-    u8 mouth_scale;
-    u8 mouth_aspect_ratio;
-    u8 mouth_y;
-    u8 facial_hair_color;
-    u8 beard_type;
-    u8 mustache_type;
-    u8 mustache_scale;
-    u8 mustache_y;
-    u8 glasses_type;
-    u8 glasses_color;
-    u8 glasses_scale;
-    u8 glasses_y;
-    u8 mole_type;
-    u8 mole_scale;
-    u8 mole_x;
-    u8 mole_y;
-    INSERT_PADDING_BYTES(1);
-
-    std::u16string Name() const;
-};
-static_assert(sizeof(MiiInfo) == 0x58, "MiiInfo has incorrect size.");
-static_assert(std::has_unique_object_representations_v<MiiInfo>,
-              "All bits of MiiInfo must contribute to its value.");
-
-bool operator==(const MiiInfo& lhs, const MiiInfo& rhs);
-bool operator!=(const MiiInfo& lhs, const MiiInfo& rhs);
-
-#pragma pack(push, 4)
-struct MiiInfoElement {
-    MiiInfo info;
-    Source source;
-};
-static_assert(sizeof(MiiInfoElement) == 0x5C, "MiiInfoElement has incorrect size.");
-
-struct MiiStoreBitFields {
-    union {
-        u32 word_0;
-
-        BitField<24, 8, u32> hair_type;
-        BitField<23, 1, u32> mole_type;
-        BitField<16, 7, u32> height;
-        BitField<15, 1, u32> hair_flip;
-        BitField<8, 7, u32> weight;
-        BitField<0, 7, u32> hair_color;
-    };
-
-    union {
-        u32 word_1;
-
-        BitField<31, 1, u32> gender;
-        BitField<24, 7, u32> eye_color;
-        BitField<16, 7, u32> eyebrow_color;
-        BitField<8, 7, u32> mouth_color;
-        BitField<0, 7, u32> facial_hair_color;
-    };
-
-    union {
-        u32 word_2;
-
-        BitField<31, 1, u32> mii_type;
-        BitField<24, 7, u32> glasses_color;
-        BitField<22, 2, u32> font_region;
-        BitField<16, 6, u32> eye_type;
-        BitField<14, 2, u32> mii_region;
-        BitField<8, 6, u32> mouth_type;
-        BitField<5, 3, u32> glasses_scale;
-        BitField<0, 5, u32> eye_y;
-    };
-
-    union {
-        u32 word_3;
-
-        BitField<29, 3, u32> mustache_type;
-        BitField<24, 5, u32> eyebrow_type;
-        BitField<21, 3, u32> beard_type;
-        BitField<16, 5, u32> nose_type;
-        BitField<13, 3, u32> mouth_aspect;
-        BitField<8, 5, u32> nose_y;
-        BitField<5, 3, u32> eyebrow_aspect;
-        BitField<0, 5, u32> mouth_y;
-    };
-
-    union {
-        u32 word_4;
-
-        BitField<29, 3, u32> eye_rotate;
-        BitField<24, 5, u32> mustache_y;
-        BitField<21, 3, u32> eye_aspect;
-        BitField<16, 5, u32> glasses_y;
-        BitField<13, 3, u32> eye_scale;
-        BitField<8, 5, u32> mole_x;
-        BitField<0, 5, u32> mole_y;
-    };
-
-    union {
-        u32 word_5;
-
-        BitField<24, 5, u32> glasses_type;
-        BitField<20, 4, u32> face_type;
-        BitField<16, 4, u32> favorite_color;
-        BitField<12, 4, u32> face_wrinkle;
-        BitField<8, 4, u32> face_color;
-        BitField<4, 4, u32> eye_x;
-        BitField<0, 4, u32> face_makeup;
-    };
-
-    union {
-        u32 word_6;
-
-        BitField<28, 4, u32> eyebrow_rotate;
-        BitField<24, 4, u32> eyebrow_scale;
-        BitField<20, 4, u32> eyebrow_y;
-        BitField<16, 4, u32> eyebrow_x;
-        BitField<12, 4, u32> mouth_scale;
-        BitField<8, 4, u32> nose_scale;
-        BitField<4, 4, u32> mole_scale;
-        BitField<0, 4, u32> mustache_scale;
-    };
-};
-static_assert(sizeof(MiiStoreBitFields) == 0x1C, "MiiStoreBitFields has incorrect size.");
-static_assert(std::is_trivially_copyable_v<MiiStoreBitFields>,
-              "MiiStoreBitFields is not trivially copyable.");
-
-struct MiiStoreData {
-    // This corresponds to the above structure MiiStoreBitFields. I did it like this because the
-    // BitField<> type makes this (and any thing that contains it) not trivially copyable, which is
-    // not suitable for our uses.
-    std::array<u8, 0x1C> data;
-    static_assert(sizeof(MiiStoreBitFields) == sizeof(data), "data field has incorrect size.");
-
-    std::array<char16_t, 10> name;
-    Common::UUID uuid;
-    u16 crc_1;
-    u16 crc_2;
-
-    std::u16string Name() const;
-};
-static_assert(sizeof(MiiStoreData) == 0x44, "MiiStoreData has incorrect size.");
-
-struct MiiStoreDataElement {
-    MiiStoreData data;
-    Source source;
-};
-static_assert(sizeof(MiiStoreDataElement) == 0x48, "MiiStoreDataElement has incorrect size.");
-
-struct MiiDatabase {
-    u32 magic; // 'NFDB'
-    std::array<MiiStoreData, MAX_MIIS> miis;
-    INSERT_PADDING_BYTES(1);
-    u8 count;
-    u16 crc;
-};
-static_assert(sizeof(MiiDatabase) == 0x1A98, "MiiDatabase has incorrect size.");
-#pragma pack(pop)
-
-// The Mii manager is responsible for loading and storing the Miis to the database in NAND along
-// with providing an easy interface for HLE emulation of the mii service.
-class MiiManager {
-public:
-    MiiManager();
-    ~MiiManager();
-
-    MiiInfo CreateRandom(RandomParameters params);
-    MiiInfo CreateDefault(u32 index);
-
-    bool CheckUpdatedFlag() const;
-    void ResetUpdatedFlag();
-
-    bool IsTestModeEnabled() const;
-
-    bool Empty() const;
-    bool Full() const;
-
-    void Clear();
-
-    u32 Size() const;
-
-    MiiInfo GetInfo(u32 index) const;
-    MiiInfoElement GetInfoElement(u32 index) const;
-    MiiStoreData GetStoreData(u32 index) const;
-    MiiStoreDataElement GetStoreDataElement(u32 index) const;
-
-    bool Remove(Common::UUID uuid);
-    u32 IndexOf(Common::UUID uuid) const;
-    u32 IndexOf(const MiiInfo& info) const;
-
-    bool Move(Common::UUID uuid, u32 new_index);
-    bool AddOrReplace(const MiiStoreData& data);
-
-    bool DestroyFile();
-    bool DeleteFile();
-
-private:
-    void WriteToFile();
-    void ReadFromFile();
-
-    MiiStoreData CreateMiiWithUniqueUUID() const;
-
-    void EnsureDatabasePartition();
-
-    MiiDatabase database;
-    bool updated_flag = false;
-    bool is_test_mode_enabled = false;
-};
-
-}; // namespace Service::Mii

src/core/hle/service/ns/errors.h

@@ -1,12 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/result.h"
-
-namespace Service::NS {
-
-constexpr ResultCode ERR_APPLICATION_LANGUAGE_NOT_FOUND{ErrorModule::NS, 300};
-}

src/core/hle/service/ns/language.cpp

@@ -1,392 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/ns/language.h"
-#include "core/hle/service/set/set.h"
-
-namespace Service::NS {
-
-constexpr ApplicationLanguagePriorityList priority_list_american_english = {{
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_british_english = {{
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_japanese = {{
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_french = {{
-    ApplicationLanguage::French,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_german = {{
-    ApplicationLanguage::German,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_latin_american_spanish = {{
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_spanish = {{
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_italian = {{
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_dutch = {{
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_canadian_french = {{
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_portuguese = {{
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_russian = {{
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_korean = {{
-    ApplicationLanguage::Korean,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_traditional_chinese = {{
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_simplified_chinese = {{
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Korean,
-}};
-
-const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(
-    const ApplicationLanguage lang) {
-    switch (lang) {
-    case ApplicationLanguage::AmericanEnglish:
-        return &priority_list_american_english;
-    case ApplicationLanguage::BritishEnglish:
-        return &priority_list_british_english;
-    case ApplicationLanguage::Japanese:
-        return &priority_list_japanese;
-    case ApplicationLanguage::French:
-        return &priority_list_french;
-    case ApplicationLanguage::German:
-        return &priority_list_german;
-    case ApplicationLanguage::LatinAmericanSpanish:
-        return &priority_list_latin_american_spanish;
-    case ApplicationLanguage::Spanish:
-        return &priority_list_spanish;
-    case ApplicationLanguage::Italian:
-        return &priority_list_italian;
-    case ApplicationLanguage::Dutch:
-        return &priority_list_dutch;
-    case ApplicationLanguage::CanadianFrench:
-        return &priority_list_canadian_french;
-    case ApplicationLanguage::Portuguese:
-        return &priority_list_portuguese;
-    case ApplicationLanguage::Russian:
-        return &priority_list_russian;
-    case ApplicationLanguage::Korean:
-        return &priority_list_korean;
-    case ApplicationLanguage::TraditionalChinese:
-        return &priority_list_traditional_chinese;
-    case ApplicationLanguage::SimplifiedChinese:
-        return &priority_list_simplified_chinese;
-    default:
-        return nullptr;
-    }
-}
-
-std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
-    const Set::LanguageCode language_code) {
-    switch (language_code) {
-    case Set::LanguageCode::EN_US:
-        return ApplicationLanguage::AmericanEnglish;
-    case Set::LanguageCode::EN_GB:
-        return ApplicationLanguage::BritishEnglish;
-    case Set::LanguageCode::JA:
-        return ApplicationLanguage::Japanese;
-    case Set::LanguageCode::FR:
-        return ApplicationLanguage::French;
-    case Set::LanguageCode::DE:
-        return ApplicationLanguage::German;
-    case Set::LanguageCode::ES_419:
-        return ApplicationLanguage::LatinAmericanSpanish;
-    case Set::LanguageCode::ES:
-        return ApplicationLanguage::Spanish;
-    case Set::LanguageCode::IT:
-        return ApplicationLanguage::Italian;
-    case Set::LanguageCode::NL:
-        return ApplicationLanguage::Dutch;
-    case Set::LanguageCode::FR_CA:
-        return ApplicationLanguage::CanadianFrench;
-    case Set::LanguageCode::PT:
-        return ApplicationLanguage::Portuguese;
-    case Set::LanguageCode::RU:
-        return ApplicationLanguage::Russian;
-    case Set::LanguageCode::KO:
-        return ApplicationLanguage::Korean;
-    case Set::LanguageCode::ZH_HANT:
-        return ApplicationLanguage::TraditionalChinese;
-    case Set::LanguageCode::ZH_HANS:
-        return ApplicationLanguage::SimplifiedChinese;
-    default:
-        return std::nullopt;
-    }
-}
-
-std::optional<Set::LanguageCode> ConvertToLanguageCode(const ApplicationLanguage lang) {
-    switch (lang) {
-    case ApplicationLanguage::AmericanEnglish:
-        return Set::LanguageCode::EN_US;
-    case ApplicationLanguage::BritishEnglish:
-        return Set::LanguageCode::EN_GB;
-    case ApplicationLanguage::Japanese:
-        return Set::LanguageCode::JA;
-    case ApplicationLanguage::French:
-        return Set::LanguageCode::FR;
-    case ApplicationLanguage::German:
-        return Set::LanguageCode::DE;
-    case ApplicationLanguage::LatinAmericanSpanish:
-        return Set::LanguageCode::ES_419;
-    case ApplicationLanguage::Spanish:
-        return Set::LanguageCode::ES;
-    case ApplicationLanguage::Italian:
-        return Set::LanguageCode::IT;
-    case ApplicationLanguage::Dutch:
-        return Set::LanguageCode::NL;
-    case ApplicationLanguage::CanadianFrench:
-        return Set::LanguageCode::FR_CA;
-    case ApplicationLanguage::Portuguese:
-        return Set::LanguageCode::PT;
-    case ApplicationLanguage::Russian:
-        return Set::LanguageCode::RU;
-    case ApplicationLanguage::Korean:
-        return Set::LanguageCode::KO;
-    case ApplicationLanguage::TraditionalChinese:
-        return Set::LanguageCode::ZH_HANT;
-    case ApplicationLanguage::SimplifiedChinese:
-        return Set::LanguageCode::ZH_HANS;
-    default:
-        return std::nullopt;
-    }
-}
-} // namespace Service::NS

src/core/hle/service/ns/language.h

@@ -1,45 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <optional>
-#include <string>
-#include "common/common_types.h"
-
-namespace Service::Set {
-enum class LanguageCode : u64;
-}
-
-namespace Service::NS {
-/// This is nn::ns::detail::ApplicationLanguage
-enum class ApplicationLanguage : u8 {
-    AmericanEnglish = 0,
-    BritishEnglish,
-    Japanese,
-    French,
-    German,
-    LatinAmericanSpanish,
-    Spanish,
-    Italian,
-    Dutch,
-    CanadianFrench,
-    Portuguese,
-    Russian,
-    Korean,
-    TraditionalChinese,
-    SimplifiedChinese,
-    Count
-};
-using ApplicationLanguagePriorityList =
-    const std::array<ApplicationLanguage, static_cast<std::size_t>(ApplicationLanguage::Count)>;
-
-constexpr u32 GetSupportedLanguageFlag(const ApplicationLanguage lang) {
-    return 1U << static_cast<u32>(lang);
-}
-
-const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(ApplicationLanguage lang);
-std::optional<ApplicationLanguage> ConvertToApplicationLanguage(Set::LanguageCode language_code);
-std::optional<Set::LanguageCode> ConvertToLanguageCode(ApplicationLanguage lang);
-} // namespace Service::NS

src/core/hle/service/ns/ns.cpp

@@ -7,507 +7,445 @@
 #include "core/file_sys/patch_manager.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/service/ns/errors.h"
-#include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/ns/pl_u.h"
-#include "core/hle/service/set/set.h"
-#include "core/settings.h"
 
 namespace Service::NS {
 
-IAccountProxyInterface::IAccountProxyInterface() : ServiceFramework{"IAccountProxyInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "CreateUserAccount"},
-    };
-    // clang-format on
+class IAccountProxyInterface final : public ServiceFramework<IAccountProxyInterface> {
+public:
+    explicit IAccountProxyInterface() : ServiceFramework{"IAccountProxyInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateUserAccount"},
+        };
+        // clang-format on
 
-    RegisterHandlers(functions);
-}
+        RegisterHandlers(functions);
+    }
+};
 
-IAccountProxyInterface::~IAccountProxyInterface() = default;
+class IApplicationManagerInterface final : public ServiceFramework<IApplicationManagerInterface> {
+public:
+    explicit IApplicationManagerInterface() : ServiceFramework{"IApplicationManagerInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ListApplicationRecord"},
+            {1, nullptr, "GenerateApplicationRecordCount"},
+            {2, nullptr, "GetApplicationRecordUpdateSystemEvent"},
+            {3, nullptr, "GetApplicationViewDeprecated"},
+            {4, nullptr, "DeleteApplicationEntity"},
+            {5, nullptr, "DeleteApplicationCompletely"},
+            {6, nullptr, "IsAnyApplicationEntityRedundant"},
+            {7, nullptr, "DeleteRedundantApplicationEntity"},
+            {8, nullptr, "IsApplicationEntityMovable"},
+            {9, nullptr, "MoveApplicationEntity"},
+            {11, nullptr, "CalculateApplicationOccupiedSize"},
+            {16, nullptr, "PushApplicationRecord"},
+            {17, nullptr, "ListApplicationRecordContentMeta"},
+            {19, nullptr, "LaunchApplicationOld"},
+            {21, nullptr, "GetApplicationContentPath"},
+            {22, nullptr, "TerminateApplication"},
+            {23, nullptr, "ResolveApplicationContentPath"},
+            {26, nullptr, "BeginInstallApplication"},
+            {27, nullptr, "DeleteApplicationRecord"},
+            {30, nullptr, "RequestApplicationUpdateInfo"},
+            {32, nullptr, "CancelApplicationDownload"},
+            {33, nullptr, "ResumeApplicationDownload"},
+            {35, nullptr, "UpdateVersionList"},
+            {36, nullptr, "PushLaunchVersion"},
+            {37, nullptr, "ListRequiredVersion"},
+            {38, nullptr, "CheckApplicationLaunchVersion"},
+            {39, nullptr, "CheckApplicationLaunchRights"},
+            {40, nullptr, "GetApplicationLogoData"},
+            {41, nullptr, "CalculateApplicationDownloadRequiredSize"},
+            {42, nullptr, "CleanupSdCard"},
+            {43, nullptr, "CheckSdCardMountStatus"},
+            {44, nullptr, "GetSdCardMountStatusChangedEvent"},
+            {45, nullptr, "GetGameCardAttachmentEvent"},
+            {46, nullptr, "GetGameCardAttachmentInfo"},
+            {47, nullptr, "GetTotalSpaceSize"},
+            {48, nullptr, "GetFreeSpaceSize"},
+            {49, nullptr, "GetSdCardRemovedEvent"},
+            {52, nullptr, "GetGameCardUpdateDetectionEvent"},
+            {53, nullptr, "DisableApplicationAutoDelete"},
+            {54, nullptr, "EnableApplicationAutoDelete"},
+            {55, nullptr, "GetApplicationDesiredLanguage"},
+            {56, nullptr, "SetApplicationTerminateResult"},
+            {57, nullptr, "ClearApplicationTerminateResult"},
+            {58, nullptr, "GetLastSdCardMountUnexpectedResult"},
+            {59, nullptr, "ConvertApplicationLanguageToLanguageCode"},
+            {60, nullptr, "ConvertLanguageCodeToApplicationLanguage"},
+            {61, nullptr, "GetBackgroundDownloadStressTaskInfo"},
+            {62, nullptr, "GetGameCardStopper"},
+            {63, nullptr, "IsSystemProgramInstalled"},
+            {64, nullptr, "StartApplyDeltaTask"},
+            {65, nullptr, "GetRequestServerStopper"},
+            {66, nullptr, "GetBackgroundApplyDeltaStressTaskInfo"},
+            {67, nullptr, "CancelApplicationApplyDelta"},
+            {68, nullptr, "ResumeApplicationApplyDelta"},
+            {69, nullptr, "CalculateApplicationApplyDeltaRequiredSize"},
+            {70, nullptr, "ResumeAll"},
+            {71, nullptr, "GetStorageSize"},
+            {80, nullptr, "RequestDownloadApplication"},
+            {81, nullptr, "RequestDownloadAddOnContent"},
+            {82, nullptr, "DownloadApplication"},
+            {83, nullptr, "CheckApplicationResumeRights"},
+            {84, nullptr, "GetDynamicCommitEvent"},
+            {85, nullptr, "RequestUpdateApplication2"},
+            {86, nullptr, "EnableApplicationCrashReport"},
+            {87, nullptr, "IsApplicationCrashReportEnabled"},
+            {90, nullptr, "BoostSystemMemoryResourceLimit"},
+            {91, nullptr, "DeprecatedLaunchApplication"},
+            {92, nullptr, "GetRunningApplicationProgramId"},
+            {93, nullptr, "GetMainApplicationProgramIndex"},
+            {94, nullptr, "LaunchApplication"},
+            {95, nullptr, "GetApplicationLaunchInfo"},
+            {96, nullptr, "AcquireApplicationLaunchInfo"},
+            {97, nullptr, "GetMainApplicationProgramIndex2"},
+            {98, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
+            {100, nullptr, "ResetToFactorySettings"},
+            {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
+            {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
+            {200, nullptr, "CalculateUserSaveDataStatistics"},
+            {201, nullptr, "DeleteUserSaveDataAll"},
+            {210, nullptr, "DeleteUserSystemSaveData"},
+            {211, nullptr, "DeleteSaveData"},
+            {220, nullptr, "UnregisterNetworkServiceAccount"},
+            {221, nullptr, "UnregisterNetworkServiceAccountWithUserSaveDataDeletion"},
+            {300, nullptr, "GetApplicationShellEvent"},
+            {301, nullptr, "PopApplicationShellEventInfo"},
+            {302, nullptr, "LaunchLibraryApplet"},
+            {303, nullptr, "TerminateLibraryApplet"},
+            {304, nullptr, "LaunchSystemApplet"},
+            {305, nullptr, "TerminateSystemApplet"},
+            {306, nullptr, "LaunchOverlayApplet"},
+            {307, nullptr, "TerminateOverlayApplet"},
+            {400, &IApplicationManagerInterface::GetApplicationControlData, "GetApplicationControlData"},
+            {401, nullptr, "InvalidateAllApplicationControlCache"},
+            {402, nullptr, "RequestDownloadApplicationControlData"},
+            {403, nullptr, "GetMaxApplicationControlCacheCount"},
+            {404, nullptr, "InvalidateApplicationControlCache"},
+            {405, nullptr, "ListApplicationControlCacheEntryInfo"},
+            {406, nullptr, "GetApplicationControlProperty"},
+            {502, nullptr, "RequestCheckGameCardRegistration"},
+            {503, nullptr, "RequestGameCardRegistrationGoldPoint"},
+            {504, nullptr, "RequestRegisterGameCard"},
+            {505, nullptr, "GetGameCardMountFailureEvent"},
+            {506, nullptr, "IsGameCardInserted"},
+            {507, nullptr, "EnsureGameCardAccess"},
+            {508, nullptr, "GetLastGameCardMountFailureResult"},
+            {509, nullptr, "ListApplicationIdOnGameCard"},
+            {600, nullptr, "CountApplicationContentMeta"},
+            {601, nullptr, "ListApplicationContentMetaStatus"},
+            {602, nullptr, "ListAvailableAddOnContent"},
+            {603, nullptr, "GetOwnedApplicationContentMetaStatus"},
+            {604, nullptr, "RegisterContentsExternalKey"},
+            {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
+            {606, nullptr, "GetContentMetaStorage"},
+            {607, nullptr, "ListAvailableAddOnContent"},
+            {700, nullptr, "PushDownloadTaskList"},
+            {701, nullptr, "ClearTaskStatusList"},
+            {702, nullptr, "RequestDownloadTaskList"},
+            {703, nullptr, "RequestEnsureDownloadTask"},
+            {704, nullptr, "ListDownloadTaskStatus"},
+            {705, nullptr, "RequestDownloadTaskListData"},
+            {800, nullptr, "RequestVersionList"},
+            {801, nullptr, "ListVersionList"},
+            {802, nullptr, "RequestVersionListData"},
+            {900, nullptr, "GetApplicationRecord"},
+            {901, nullptr, "GetApplicationRecordProperty"},
+            {902, nullptr, "EnableApplicationAutoUpdate"},
+            {903, nullptr, "DisableApplicationAutoUpdate"},
+            {904, nullptr, "TouchApplication"},
+            {905, nullptr, "RequestApplicationUpdate"},
+            {906, nullptr, "IsApplicationUpdateRequested"},
+            {907, nullptr, "WithdrawApplicationUpdateRequest"},
+            {908, nullptr, "ListApplicationRecordInstalledContentMeta"},
+            {909, nullptr, "WithdrawCleanupAddOnContentsWithNoRightsRecommendation"},
+            {910, nullptr, "HasApplicationRecord"},
+            {911, nullptr, "SetPreInstalledApplication"},
+            {912, nullptr, "ClearPreInstalledApplicationFlag"},
+            {1000, nullptr, "RequestVerifyApplicationDeprecated"},
+            {1001, nullptr, "CorruptApplicationForDebug"},
+            {1002, nullptr, "RequestVerifyAddOnContentsRights"},
+            {1003, nullptr, "RequestVerifyApplication"},
+            {1004, nullptr, "CorruptContentForDebug"},
+            {1200, nullptr, "NeedsUpdateVulnerability"},
+            {1300, nullptr, "IsAnyApplicationEntityInstalled"},
+            {1301, nullptr, "DeleteApplicationContentEntities"},
+            {1302, nullptr, "CleanupUnrecordedApplicationEntity"},
+            {1303, nullptr, "CleanupAddOnContentsWithNoRights"},
+            {1304, nullptr, "DeleteApplicationContentEntity"},
+            {1305, nullptr, "TryDeleteRunningApplicationEntity"},
+            {1306, nullptr, "TryDeleteRunningApplicationCompletely"},
+            {1307, nullptr, "TryDeleteRunningApplicationContentEntities"},
+            {1308, nullptr, "DeleteApplicationCompletelyForDebug"},
+            {1309, nullptr, "CleanupUnavailableAddOnContents"},
+            {1400, nullptr, "PrepareShutdown"},
+            {1500, nullptr, "FormatSdCard"},
+            {1501, nullptr, "NeedsSystemUpdateToFormatSdCard"},
+            {1502, nullptr, "GetLastSdCardFormatUnexpectedResult"},
+            {1504, nullptr, "InsertSdCard"},
+            {1505, nullptr, "RemoveSdCard"},
+            {1600, nullptr, "GetSystemSeedForPseudoDeviceId"},
+            {1601, nullptr, "ResetSystemSeedForPseudoDeviceId"},
+            {1700, nullptr, "ListApplicationDownloadingContentMeta"},
+            {1701, nullptr, "GetApplicationView"},
+            {1702, nullptr, "GetApplicationDownloadTaskStatus"},
+            {1703, nullptr, "GetApplicationViewDownloadErrorContext"},
+            {1800, nullptr, "IsNotificationSetupCompleted"},
+            {1801, nullptr, "GetLastNotificationInfoCount"},
+            {1802, nullptr, "ListLastNotificationInfo"},
+            {1803, nullptr, "ListNotificationTask"},
+            {1900, nullptr, "IsActiveAccount"},
+            {1901, nullptr, "RequestDownloadApplicationPrepurchasedRights"},
+            {1902, nullptr, "GetApplicationTicketInfo"},
+            {2000, nullptr, "GetSystemDeliveryInfo"},
+            {2001, nullptr, "SelectLatestSystemDeliveryInfo"},
+            {2002, nullptr, "VerifyDeliveryProtocolVersion"},
+            {2003, nullptr, "GetApplicationDeliveryInfo"},
+            {2004, nullptr, "HasAllContentsToDeliver"},
+            {2005, nullptr, "CompareApplicationDeliveryInfo"},
+            {2006, nullptr, "CanDeliverApplication"},
+            {2007, nullptr, "ListContentMetaKeyToDeliverApplication"},
+            {2008, nullptr, "NeedsSystemUpdateToDeliverApplication"},
+            {2009, nullptr, "EstimateRequiredSize"},
+            {2010, nullptr, "RequestReceiveApplication"},
+            {2011, nullptr, "CommitReceiveApplication"},
+            {2012, nullptr, "GetReceiveApplicationProgress"},
+            {2013, nullptr, "RequestSendApplication"},
+            {2014, nullptr, "GetSendApplicationProgress"},
+            {2015, nullptr, "CompareSystemDeliveryInfo"},
+            {2016, nullptr, "ListNotCommittedContentMeta"},
+            {2017, nullptr, "CreateDownloadTask"},
+            {2018, nullptr, "GetApplicationDeliveryInfoHash"},
+            {2050, nullptr, "GetApplicationRightsOnClient"},
+            {2100, nullptr, "GetApplicationTerminateResult"},
+            {2101, nullptr, "GetRawApplicationTerminateResult"},
+            {2150, nullptr, "CreateRightsEnvironment"},
+            {2151, nullptr, "DestroyRightsEnvironment"},
+            {2152, nullptr, "ActivateRightsEnvironment"},
+            {2153, nullptr, "DeactivateRightsEnvironment"},
+            {2154, nullptr, "ForceActivateRightsContextForExit"},
+            {2160, nullptr, "AddTargetApplicationToRightsEnvironment"},
+            {2161, nullptr, "SetUsersToRightsEnvironment"},
+            {2170, nullptr, "GetRightsEnvironmentStatus"},
+            {2171, nullptr, "GetRightsEnvironmentStatusChangedEvent"},
+            {2180, nullptr, "RequestExtendRightsInRightsEnvironment"},
+            {2181, nullptr, "GetLastResultOfExtendRightsInRightsEnvironment"},
+            {2182, nullptr, "SetActiveRightsContextUsingStateToRightsEnvironment"},
+            {2190, nullptr, "GetRightsEnvironmentHandleForApplication"},
+            {2199, nullptr, "GetRightsEnvironmentCountForDebug"},
+            {2200, nullptr, "GetGameCardApplicationCopyIdentifier"},
+            {2201, nullptr, "GetInstalledApplicationCopyIdentifier"},
+            {2250, nullptr, "RequestReportActiveELicence"},
+            {2300, nullptr, "ListEventLog"},
+        };
+        // clang-format on
 
-IApplicationManagerInterface::IApplicationManagerInterface()
-    : ServiceFramework{"IApplicationManagerInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "ListApplicationRecord"},
-        {1, nullptr, "GenerateApplicationRecordCount"},
-        {2, nullptr, "GetApplicationRecordUpdateSystemEvent"},
-        {3, nullptr, "GetApplicationViewDeprecated"},
-        {4, nullptr, "DeleteApplicationEntity"},
-        {5, nullptr, "DeleteApplicationCompletely"},
-        {6, nullptr, "IsAnyApplicationEntityRedundant"},
-        {7, nullptr, "DeleteRedundantApplicationEntity"},
-        {8, nullptr, "IsApplicationEntityMovable"},
-        {9, nullptr, "MoveApplicationEntity"},
-        {11, nullptr, "CalculateApplicationOccupiedSize"},
-        {16, nullptr, "PushApplicationRecord"},
-        {17, nullptr, "ListApplicationRecordContentMeta"},
-        {19, nullptr, "LaunchApplicationOld"},
-        {21, nullptr, "GetApplicationContentPath"},
-        {22, nullptr, "TerminateApplication"},
-        {23, nullptr, "ResolveApplicationContentPath"},
-        {26, nullptr, "BeginInstallApplication"},
-        {27, nullptr, "DeleteApplicationRecord"},
-        {30, nullptr, "RequestApplicationUpdateInfo"},
-        {32, nullptr, "CancelApplicationDownload"},
-        {33, nullptr, "ResumeApplicationDownload"},
-        {35, nullptr, "UpdateVersionList"},
-        {36, nullptr, "PushLaunchVersion"},
-        {37, nullptr, "ListRequiredVersion"},
-        {38, nullptr, "CheckApplicationLaunchVersion"},
-        {39, nullptr, "CheckApplicationLaunchRights"},
-        {40, nullptr, "GetApplicationLogoData"},
-        {41, nullptr, "CalculateApplicationDownloadRequiredSize"},
-        {42, nullptr, "CleanupSdCard"},
-        {43, nullptr, "CheckSdCardMountStatus"},
-        {44, nullptr, "GetSdCardMountStatusChangedEvent"},
-        {45, nullptr, "GetGameCardAttachmentEvent"},
-        {46, nullptr, "GetGameCardAttachmentInfo"},
-        {47, nullptr, "GetTotalSpaceSize"},
-        {48, nullptr, "GetFreeSpaceSize"},
-        {49, nullptr, "GetSdCardRemovedEvent"},
-        {52, nullptr, "GetGameCardUpdateDetectionEvent"},
-        {53, nullptr, "DisableApplicationAutoDelete"},
-        {54, nullptr, "EnableApplicationAutoDelete"},
-        {55, &IApplicationManagerInterface::GetApplicationDesiredLanguage, "GetApplicationDesiredLanguage"},
-        {56, nullptr, "SetApplicationTerminateResult"},
-        {57, nullptr, "ClearApplicationTerminateResult"},
-        {58, nullptr, "GetLastSdCardMountUnexpectedResult"},
-        {59, &IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode, "ConvertApplicationLanguageToLanguageCode"},
-        {60, nullptr, "ConvertLanguageCodeToApplicationLanguage"},
-        {61, nullptr, "GetBackgroundDownloadStressTaskInfo"},
-        {62, nullptr, "GetGameCardStopper"},
-        {63, nullptr, "IsSystemProgramInstalled"},
-        {64, nullptr, "StartApplyDeltaTask"},
-        {65, nullptr, "GetRequestServerStopper"},
-        {66, nullptr, "GetBackgroundApplyDeltaStressTaskInfo"},
-        {67, nullptr, "CancelApplicationApplyDelta"},
-        {68, nullptr, "ResumeApplicationApplyDelta"},
-        {69, nullptr, "CalculateApplicationApplyDeltaRequiredSize"},
-        {70, nullptr, "ResumeAll"},
-        {71, nullptr, "GetStorageSize"},
-        {80, nullptr, "RequestDownloadApplication"},
-        {81, nullptr, "RequestDownloadAddOnContent"},
-        {82, nullptr, "DownloadApplication"},
-        {83, nullptr, "CheckApplicationResumeRights"},
-        {84, nullptr, "GetDynamicCommitEvent"},
-        {85, nullptr, "RequestUpdateApplication2"},
-        {86, nullptr, "EnableApplicationCrashReport"},
-        {87, nullptr, "IsApplicationCrashReportEnabled"},
-        {90, nullptr, "BoostSystemMemoryResourceLimit"},
-        {91, nullptr, "DeprecatedLaunchApplication"},
-        {92, nullptr, "GetRunningApplicationProgramId"},
-        {93, nullptr, "GetMainApplicationProgramIndex"},
-        {94, nullptr, "LaunchApplication"},
-        {95, nullptr, "GetApplicationLaunchInfo"},
-        {96, nullptr, "AcquireApplicationLaunchInfo"},
-        {97, nullptr, "GetMainApplicationProgramIndex2"},
-        {98, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
-        {100, nullptr, "ResetToFactorySettings"},
-        {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
-        {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
-        {200, nullptr, "CalculateUserSaveDataStatistics"},
-        {201, nullptr, "DeleteUserSaveDataAll"},
-        {210, nullptr, "DeleteUserSystemSaveData"},
-        {211, nullptr, "DeleteSaveData"},
-        {220, nullptr, "UnregisterNetworkServiceAccount"},
-        {221, nullptr, "UnregisterNetworkServiceAccountWithUserSaveDataDeletion"},
-        {300, nullptr, "GetApplicationShellEvent"},
-        {301, nullptr, "PopApplicationShellEventInfo"},
-        {302, nullptr, "LaunchLibraryApplet"},
-        {303, nullptr, "TerminateLibraryApplet"},
-        {304, nullptr, "LaunchSystemApplet"},
-        {305, nullptr, "TerminateSystemApplet"},
-        {306, nullptr, "LaunchOverlayApplet"},
-        {307, nullptr, "TerminateOverlayApplet"},
-        {400, &IApplicationManagerInterface::GetApplicationControlData, "GetApplicationControlData"},
-        {401, nullptr, "InvalidateAllApplicationControlCache"},
-        {402, nullptr, "RequestDownloadApplicationControlData"},
-        {403, nullptr, "GetMaxApplicationControlCacheCount"},
-        {404, nullptr, "InvalidateApplicationControlCache"},
-        {405, nullptr, "ListApplicationControlCacheEntryInfo"},
-        {406, nullptr, "GetApplicationControlProperty"},
-        {502, nullptr, "RequestCheckGameCardRegistration"},
-        {503, nullptr, "RequestGameCardRegistrationGoldPoint"},
-        {504, nullptr, "RequestRegisterGameCard"},
-        {505, nullptr, "GetGameCardMountFailureEvent"},
-        {506, nullptr, "IsGameCardInserted"},
-        {507, nullptr, "EnsureGameCardAccess"},
-        {508, nullptr, "GetLastGameCardMountFailureResult"},
-        {509, nullptr, "ListApplicationIdOnGameCard"},
-        {600, nullptr, "CountApplicationContentMeta"},
-        {601, nullptr, "ListApplicationContentMetaStatus"},
-        {602, nullptr, "ListAvailableAddOnContent"},
-        {603, nullptr, "GetOwnedApplicationContentMetaStatus"},
-        {604, nullptr, "RegisterContentsExternalKey"},
-        {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
-        {606, nullptr, "GetContentMetaStorage"},
-        {607, nullptr, "ListAvailableAddOnContent"},
-        {700, nullptr, "PushDownloadTaskList"},
-        {701, nullptr, "ClearTaskStatusList"},
-        {702, nullptr, "RequestDownloadTaskList"},
-        {703, nullptr, "RequestEnsureDownloadTask"},
-        {704, nullptr, "ListDownloadTaskStatus"},
-        {705, nullptr, "RequestDownloadTaskListData"},
-        {800, nullptr, "RequestVersionList"},
-        {801, nullptr, "ListVersionList"},
-        {802, nullptr, "RequestVersionListData"},
-        {900, nullptr, "GetApplicationRecord"},
-        {901, nullptr, "GetApplicationRecordProperty"},
-        {902, nullptr, "EnableApplicationAutoUpdate"},
-        {903, nullptr, "DisableApplicationAutoUpdate"},
-        {904, nullptr, "TouchApplication"},
-        {905, nullptr, "RequestApplicationUpdate"},
-        {906, nullptr, "IsApplicationUpdateRequested"},
-        {907, nullptr, "WithdrawApplicationUpdateRequest"},
-        {908, nullptr, "ListApplicationRecordInstalledContentMeta"},
-        {909, nullptr, "WithdrawCleanupAddOnContentsWithNoRightsRecommendation"},
-        {910, nullptr, "HasApplicationRecord"},
-        {911, nullptr, "SetPreInstalledApplication"},
-        {912, nullptr, "ClearPreInstalledApplicationFlag"},
-        {1000, nullptr, "RequestVerifyApplicationDeprecated"},
-        {1001, nullptr, "CorruptApplicationForDebug"},
-        {1002, nullptr, "RequestVerifyAddOnContentsRights"},
-        {1003, nullptr, "RequestVerifyApplication"},
-        {1004, nullptr, "CorruptContentForDebug"},
-        {1200, nullptr, "NeedsUpdateVulnerability"},
-        {1300, nullptr, "IsAnyApplicationEntityInstalled"},
-        {1301, nullptr, "DeleteApplicationContentEntities"},
-        {1302, nullptr, "CleanupUnrecordedApplicationEntity"},
-        {1303, nullptr, "CleanupAddOnContentsWithNoRights"},
-        {1304, nullptr, "DeleteApplicationContentEntity"},
-        {1305, nullptr, "TryDeleteRunningApplicationEntity"},
-        {1306, nullptr, "TryDeleteRunningApplicationCompletely"},
-        {1307, nullptr, "TryDeleteRunningApplicationContentEntities"},
-        {1308, nullptr, "DeleteApplicationCompletelyForDebug"},
-        {1309, nullptr, "CleanupUnavailableAddOnContents"},
-        {1400, nullptr, "PrepareShutdown"},
-        {1500, nullptr, "FormatSdCard"},
-        {1501, nullptr, "NeedsSystemUpdateToFormatSdCard"},
-        {1502, nullptr, "GetLastSdCardFormatUnexpectedResult"},
-        {1504, nullptr, "InsertSdCard"},
-        {1505, nullptr, "RemoveSdCard"},
-        {1600, nullptr, "GetSystemSeedForPseudoDeviceId"},
-        {1601, nullptr, "ResetSystemSeedForPseudoDeviceId"},
-        {1700, nullptr, "ListApplicationDownloadingContentMeta"},
-        {1701, nullptr, "GetApplicationView"},
-        {1702, nullptr, "GetApplicationDownloadTaskStatus"},
-        {1703, nullptr, "GetApplicationViewDownloadErrorContext"},
-        {1800, nullptr, "IsNotificationSetupCompleted"},
-        {1801, nullptr, "GetLastNotificationInfoCount"},
-        {1802, nullptr, "ListLastNotificationInfo"},
-        {1803, nullptr, "ListNotificationTask"},
-        {1900, nullptr, "IsActiveAccount"},
-        {1901, nullptr, "RequestDownloadApplicationPrepurchasedRights"},
-        {1902, nullptr, "GetApplicationTicketInfo"},
-        {2000, nullptr, "GetSystemDeliveryInfo"},
-        {2001, nullptr, "SelectLatestSystemDeliveryInfo"},
-        {2002, nullptr, "VerifyDeliveryProtocolVersion"},
-        {2003, nullptr, "GetApplicationDeliveryInfo"},
-        {2004, nullptr, "HasAllContentsToDeliver"},
-        {2005, nullptr, "CompareApplicationDeliveryInfo"},
-        {2006, nullptr, "CanDeliverApplication"},
-        {2007, nullptr, "ListContentMetaKeyToDeliverApplication"},
-        {2008, nullptr, "NeedsSystemUpdateToDeliverApplication"},
-        {2009, nullptr, "EstimateRequiredSize"},
-        {2010, nullptr, "RequestReceiveApplication"},
-        {2011, nullptr, "CommitReceiveApplication"},
-        {2012, nullptr, "GetReceiveApplicationProgress"},
-        {2013, nullptr, "RequestSendApplication"},
-        {2014, nullptr, "GetSendApplicationProgress"},
-        {2015, nullptr, "CompareSystemDeliveryInfo"},
-        {2016, nullptr, "ListNotCommittedContentMeta"},
-        {2017, nullptr, "CreateDownloadTask"},
-        {2018, nullptr, "GetApplicationDeliveryInfoHash"},
-        {2050, nullptr, "GetApplicationRightsOnClient"},
-        {2100, nullptr, "GetApplicationTerminateResult"},
-        {2101, nullptr, "GetRawApplicationTerminateResult"},
-        {2150, nullptr, "CreateRightsEnvironment"},
-        {2151, nullptr, "DestroyRightsEnvironment"},
-        {2152, nullptr, "ActivateRightsEnvironment"},
-        {2153, nullptr, "DeactivateRightsEnvironment"},
-        {2154, nullptr, "ForceActivateRightsContextForExit"},
-        {2160, nullptr, "AddTargetApplicationToRightsEnvironment"},
-        {2161, nullptr, "SetUsersToRightsEnvironment"},
-        {2170, nullptr, "GetRightsEnvironmentStatus"},
-        {2171, nullptr, "GetRightsEnvironmentStatusChangedEvent"},
-        {2180, nullptr, "RequestExtendRightsInRightsEnvironment"},
-        {2181, nullptr, "GetLastResultOfExtendRightsInRightsEnvironment"},
-        {2182, nullptr, "SetActiveRightsContextUsingStateToRightsEnvironment"},
-        {2190, nullptr, "GetRightsEnvironmentHandleForApplication"},
-        {2199, nullptr, "GetRightsEnvironmentCountForDebug"},
-        {2200, nullptr, "GetGameCardApplicationCopyIdentifier"},
-        {2201, nullptr, "GetInstalledApplicationCopyIdentifier"},
-        {2250, nullptr, "RequestReportActiveELicence"},
-        {2300, nullptr, "ListEventLog"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IApplicationManagerInterface::~IApplicationManagerInterface() = default;
-
-void IApplicationManagerInterface::GetApplicationControlData(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto flag = rp.PopRaw<u64>();
-    LOG_DEBUG(Service_NS, "called with flag={:016X}", flag);
-
-    const auto title_id = rp.PopRaw<u64>();
-
-    const auto size = ctx.GetWriteBufferSize();
-
-    const FileSys::PatchManager pm{title_id};
-    const auto control = pm.GetControlMetadata();
-
-    std::vector<u8> out;
-
-    if (control.first != nullptr) {
-        if (size < 0x4000) {
-            LOG_ERROR(Service_NS,
-                      "output buffer is too small! (actual={:016X}, expected_min=0x4000)", size);
-            IPC::ResponseBuilder rb{ctx, 2};
-            // TODO(DarkLordZach): Find a better error code for this.
-            rb.Push(ResultCode(-1));
-            return;
-        }
-
-        out.resize(0x4000);
-        const auto bytes = control.first->GetRawBytes();
-        std::memcpy(out.data(), bytes.data(), bytes.size());
-    } else {
-        LOG_WARNING(Service_NS, "missing NACP data for title_id={:016X}, defaulting to zeros.",
-                    title_id);
-        out.resize(std::min<u64>(0x4000, size));
+        RegisterHandlers(functions);
     }
 
-    if (control.second != nullptr) {
-        if (size < 0x4000 + control.second->GetSize()) {
-            LOG_ERROR(Service_NS,
-                      "output buffer is too small! (actual={:016X}, expected_min={:016X})", size,
-                      0x4000 + control.second->GetSize());
-            IPC::ResponseBuilder rb{ctx, 2};
-            // TODO(DarkLordZach): Find a better error code for this.
-            rb.Push(ResultCode(-1));
-            return;
+    void GetApplicationControlData(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto flag = rp.PopRaw<u64>();
+        LOG_DEBUG(Service_NS, "called with flag={:016X}", flag);
+
+        const auto title_id = rp.PopRaw<u64>();
+
+        const auto size = ctx.GetWriteBufferSize();
+
+        const FileSys::PatchManager pm{title_id};
+        const auto control = pm.GetControlMetadata();
+
+        std::vector<u8> out;
+
+        if (control.first != nullptr) {
+            if (size < 0x4000) {
+                LOG_ERROR(Service_NS,
+                          "output buffer is too small! (actual={:016X}, expected_min=0x4000)",
+                          size);
+                IPC::ResponseBuilder rb{ctx, 2};
+                // TODO(DarkLordZach): Find a better error code for this.
+                rb.Push(ResultCode(-1));
+                return;
+            }
+
+            out.resize(0x4000);
+            const auto bytes = control.first->GetRawBytes();
+            std::memcpy(out.data(), bytes.data(), bytes.size());
+        } else {
+            LOG_WARNING(Service_NS, "missing NACP data for title_id={:016X}, defaulting to zeros.",
+                        title_id);
+            out.resize(std::min<u64>(0x4000, size));
         }
 
-        out.resize(0x4000 + control.second->GetSize());
-        control.second->Read(out.data() + 0x4000, control.second->GetSize());
-    } else {
-        LOG_WARNING(Service_NS, "missing icon data for title_id={:016X}, defaulting to zeros.",
-                    title_id);
-    }
+        if (control.second != nullptr) {
+            if (size < 0x4000 + control.second->GetSize()) {
+                LOG_ERROR(Service_NS,
+                          "output buffer is too small! (actual={:016X}, expected_min={:016X})",
+                          size, 0x4000 + control.second->GetSize());
+                IPC::ResponseBuilder rb{ctx, 2};
+                // TODO(DarkLordZach): Find a better error code for this.
+                rb.Push(ResultCode(-1));
+                return;
+            }
 
-    ctx.WriteBuffer(out);
+            out.resize(0x4000 + control.second->GetSize());
+            control.second->Read(out.data() + 0x4000, control.second->GetSize());
+        } else {
+            LOG_WARNING(Service_NS, "missing icon data for title_id={:016X}, defaulting to zeros.",
+                        title_id);
+        }
 
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(static_cast<u32>(out.size()));
-}
+        ctx.WriteBuffer(out);
 
-void IApplicationManagerInterface::GetApplicationDesiredLanguage(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto supported_languages = rp.Pop<u32>();
-
-    const auto res = GetApplicationDesiredLanguage(supported_languages);
-    if (res.Succeeded()) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(*res);
-    } else {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push<u32>(static_cast<u32>(out.size()));
     }
-}
+};
 
-ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
-    const u32 supported_languages) {
-    LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages);
+class IApplicationVersionInterface final : public ServiceFramework<IApplicationVersionInterface> {
+public:
+    explicit IApplicationVersionInterface() : ServiceFramework{"IApplicationVersionInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetLaunchRequiredVersion"},
+            {1, nullptr, "UpgradeLaunchRequiredVersion"},
+            {35, nullptr, "UpdateVersionList"},
+            {36, nullptr, "PushLaunchVersion"},
+            {37, nullptr, "ListRequiredVersion"},
+            {800, nullptr, "RequestVersionList"},
+            {801, nullptr, "ListVersionList"},
+            {802, nullptr, "RequestVersionListData"},
+            {1000, nullptr, "PerformAutoUpdate"},
+        };
+        // clang-format on
 
-    // Get language code from settings
-    const auto language_code = Set::GetLanguageCodeFromIndex(Settings::values.language_index);
-
-    // Convert to application language, get priority list
-    const auto application_language = ConvertToApplicationLanguage(language_code);
-    if (application_language == std::nullopt) {
-        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+        RegisterHandlers(functions);
     }
-    const auto priority_list = GetApplicationLanguagePriorityList(*application_language);
-    if (!priority_list) {
-        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+};
+
+class IContentManagerInterface final : public ServiceFramework<IContentManagerInterface> {
+public:
+    explicit IContentManagerInterface() : ServiceFramework{"IContentManagerInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {11, nullptr, "CalculateApplicationOccupiedSize"},
+            {43, nullptr, "CheckSdCardMountStatus"},
+            {47, nullptr, "GetTotalSpaceSize"},
+            {48, nullptr, "GetFreeSpaceSize"},
+            {600, nullptr, "CountApplicationContentMeta"},
+            {601, nullptr, "ListApplicationContentMetaStatus"},
+            {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
+            {607, nullptr, "IsAnyApplicationRunning"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
     }
+};
 
-    // Try to find a valid language.
-    for (const auto lang : *priority_list) {
-        const auto supported_flag = GetSupportedLanguageFlag(lang);
-        if (supported_languages == 0 || (supported_languages & supported_flag) == supported_flag) {
-            return MakeResult(static_cast<u8>(lang));
-        }
+class IDocumentInterface final : public ServiceFramework<IDocumentInterface> {
+public:
+    explicit IDocumentInterface() : ServiceFramework{"IDocumentInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {21, nullptr, "GetApplicationContentPath"},
+            {23, nullptr, "ResolveApplicationContentPath"},
+            {93, nullptr, "GetRunningApplicationProgramId"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
     }
+};
 
-    return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
-}
+class IDownloadTaskInterface final : public ServiceFramework<IDownloadTaskInterface> {
+public:
+    explicit IDownloadTaskInterface() : ServiceFramework{"IDownloadTaskInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {701, nullptr, "ClearTaskStatusList"},
+            {702, nullptr, "RequestDownloadTaskList"},
+            {703, nullptr, "RequestEnsureDownloadTask"},
+            {704, nullptr, "ListDownloadTaskStatus"},
+            {705, nullptr, "RequestDownloadTaskListData"},
+            {706, nullptr, "TryCommitCurrentApplicationDownloadTask"},
+            {707, nullptr, "EnableAutoCommit"},
+            {708, nullptr, "DisableAutoCommit"},
+            {709, nullptr, "TriggerDynamicCommitEvent"},
+        };
+        // clang-format on
 
-void IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
-    Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto application_language = rp.Pop<u8>();
-
-    const auto res = ConvertApplicationLanguageToLanguageCode(application_language);
-    if (res.Succeeded()) {
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(*res);
-    } else {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        RegisterHandlers(functions);
     }
-}
+};
 
-ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
-    u8 application_language) {
-    const auto language_code =
-        ConvertToLanguageCode(static_cast<ApplicationLanguage>(application_language));
-    if (language_code == std::nullopt) {
-        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+class IECommerceInterface final : public ServiceFramework<IECommerceInterface> {
+public:
+    explicit IECommerceInterface() : ServiceFramework{"IECommerceInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestLinkDevice"},
+            {1, nullptr, "RequestCleanupAllPreInstalledApplications"},
+            {2, nullptr, "RequestCleanupPreInstalledApplication"},
+            {3, nullptr, "RequestSyncRights"},
+            {4, nullptr, "RequestUnlinkDevice"},
+            {5, nullptr, "RequestRevokeAllELicense"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
     }
+};
 
-    return MakeResult(static_cast<u64>(*language_code));
-}
-
-IApplicationVersionInterface::IApplicationVersionInterface()
-    : ServiceFramework{"IApplicationVersionInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetLaunchRequiredVersion"},
-        {1, nullptr, "UpgradeLaunchRequiredVersion"},
-        {35, nullptr, "UpdateVersionList"},
-        {36, nullptr, "PushLaunchVersion"},
-        {37, nullptr, "ListRequiredVersion"},
-        {800, nullptr, "RequestVersionList"},
-        {801, nullptr, "ListVersionList"},
-        {802, nullptr, "RequestVersionListData"},
-        {1000, nullptr, "PerformAutoUpdate"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IApplicationVersionInterface::~IApplicationVersionInterface() = default;
-
-IContentManagerInterface::IContentManagerInterface()
-    : ServiceFramework{"IContentManagerInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {11, nullptr, "CalculateApplicationOccupiedSize"},
-        {43, nullptr, "CheckSdCardMountStatus"},
-        {47, nullptr, "GetTotalSpaceSize"},
-        {48, nullptr, "GetFreeSpaceSize"},
-        {600, nullptr, "CountApplicationContentMeta"},
-        {601, nullptr, "ListApplicationContentMetaStatus"},
-        {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
-        {607, nullptr, "IsAnyApplicationRunning"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IContentManagerInterface::~IContentManagerInterface() = default;
-
-IDocumentInterface::IDocumentInterface() : ServiceFramework{"IDocumentInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {21, nullptr, "GetApplicationContentPath"},
-        {23, nullptr, "ResolveApplicationContentPath"},
-        {93, nullptr, "GetRunningApplicationProgramId"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IDocumentInterface::~IDocumentInterface() = default;
-
-IDownloadTaskInterface::IDownloadTaskInterface() : ServiceFramework{"IDownloadTaskInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {701, nullptr, "ClearTaskStatusList"},
-        {702, nullptr, "RequestDownloadTaskList"},
-        {703, nullptr, "RequestEnsureDownloadTask"},
-        {704, nullptr, "ListDownloadTaskStatus"},
-        {705, nullptr, "RequestDownloadTaskListData"},
-        {706, nullptr, "TryCommitCurrentApplicationDownloadTask"},
-        {707, nullptr, "EnableAutoCommit"},
-        {708, nullptr, "DisableAutoCommit"},
-        {709, nullptr, "TriggerDynamicCommitEvent"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IDownloadTaskInterface::~IDownloadTaskInterface() = default;
-
-IECommerceInterface::IECommerceInterface() : ServiceFramework{"IECommerceInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "RequestLinkDevice"},
-        {1, nullptr, "RequestCleanupAllPreInstalledApplications"},
-        {2, nullptr, "RequestCleanupPreInstalledApplication"},
-        {3, nullptr, "RequestSyncRights"},
-        {4, nullptr, "RequestUnlinkDevice"},
-        {5, nullptr, "RequestRevokeAllELicense"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IECommerceInterface::~IECommerceInterface() = default;
-
-IFactoryResetInterface::IFactoryResetInterface::IFactoryResetInterface()
-    : ServiceFramework{"IFactoryResetInterface"} {
-    // clang-format off
+class IFactoryResetInterface final : public ServiceFramework<IFactoryResetInterface> {
+public:
+    explicit IFactoryResetInterface() : ServiceFramework{"IFactoryResetInterface"} {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {100, nullptr, "ResetToFactorySettings"},
             {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
             {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
         };
-    // clang-format on
+        // clang-format on
 
-    RegisterHandlers(functions);
-}
+        RegisterHandlers(functions);
+    }
+};
 
-IFactoryResetInterface::~IFactoryResetInterface() = default;
+class NS final : public ServiceFramework<NS> {
+public:
+    explicit NS(const char* name) : ServiceFramework{name} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {7992, &NS::PushInterface<IECommerceInterface>, "GetECommerceInterface"},
+            {7993, &NS::PushInterface<IApplicationVersionInterface>, "GetApplicationVersionInterface"},
+            {7994, &NS::PushInterface<IFactoryResetInterface>, "GetFactoryResetInterface"},
+            {7995, &NS::PushInterface<IAccountProxyInterface>, "GetAccountProxyInterface"},
+            {7996, &NS::PushInterface<IApplicationManagerInterface>, "GetApplicationManagerInterface"},
+            {7997, &NS::PushInterface<IDownloadTaskInterface>, "GetDownloadTaskInterface"},
+            {7998, &NS::PushInterface<IContentManagerInterface>, "GetContentManagementInterface"},
+            {7999, &NS::PushInterface<IDocumentInterface>, "GetDocumentInterface"},
+        };
+        // clang-format on
 
-NS::NS(const char* name) : ServiceFramework{name} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {7992, &NS::PushInterface<IECommerceInterface>, "GetECommerceInterface"},
-        {7993, &NS::PushInterface<IApplicationVersionInterface>, "GetApplicationVersionInterface"},
-        {7994, &NS::PushInterface<IFactoryResetInterface>, "GetFactoryResetInterface"},
-        {7995, &NS::PushInterface<IAccountProxyInterface>, "GetAccountProxyInterface"},
-        {7996, &NS::PushInterface<IApplicationManagerInterface>, "GetApplicationManagerInterface"},
-        {7997, &NS::PushInterface<IDownloadTaskInterface>, "GetDownloadTaskInterface"},
-        {7998, &NS::PushInterface<IContentManagerInterface>, "GetContentManagementInterface"},
-        {7999, &NS::PushInterface<IDocumentInterface>, "GetDocumentInterface"},
-    };
-    // clang-format on
+        RegisterHandlers(functions);
+    }
 
-    RegisterHandlers(functions);
-}
+private:
+    template <typename T>
+    void PushInterface(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NS, "called");
 
-NS::~NS() = default;
-
-std::shared_ptr<IApplicationManagerInterface> NS::GetApplicationManagerInterface() const {
-    return GetInterface<IApplicationManagerInterface>();
-}
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<T>();
+    }
+};
 
 class NS_DEV final : public ServiceFramework<NS_DEV> {
 public:

src/core/hle/service/ns/ns.h

@@ -8,88 +8,6 @@
 
 namespace Service::NS {
 
-class IAccountProxyInterface final : public ServiceFramework<IAccountProxyInterface> {
-public:
-    explicit IAccountProxyInterface();
-    ~IAccountProxyInterface();
-};
-
-class IApplicationManagerInterface final : public ServiceFramework<IApplicationManagerInterface> {
-public:
-    explicit IApplicationManagerInterface();
-    ~IApplicationManagerInterface();
-
-    ResultVal<u8> GetApplicationDesiredLanguage(u32 supported_languages);
-    ResultVal<u64> ConvertApplicationLanguageToLanguageCode(u8 application_language);
-
-private:
-    void GetApplicationControlData(Kernel::HLERequestContext& ctx);
-    void GetApplicationDesiredLanguage(Kernel::HLERequestContext& ctx);
-    void ConvertApplicationLanguageToLanguageCode(Kernel::HLERequestContext& ctx);
-};
-
-class IApplicationVersionInterface final : public ServiceFramework<IApplicationVersionInterface> {
-public:
-    explicit IApplicationVersionInterface();
-    ~IApplicationVersionInterface();
-};
-
-class IContentManagerInterface final : public ServiceFramework<IContentManagerInterface> {
-public:
-    explicit IContentManagerInterface();
-    ~IContentManagerInterface();
-};
-
-class IDocumentInterface final : public ServiceFramework<IDocumentInterface> {
-public:
-    explicit IDocumentInterface();
-    ~IDocumentInterface();
-};
-
-class IDownloadTaskInterface final : public ServiceFramework<IDownloadTaskInterface> {
-public:
-    explicit IDownloadTaskInterface();
-    ~IDownloadTaskInterface();
-};
-
-class IECommerceInterface final : public ServiceFramework<IECommerceInterface> {
-public:
-    explicit IECommerceInterface();
-    ~IECommerceInterface();
-};
-
-class IFactoryResetInterface final : public ServiceFramework<IFactoryResetInterface> {
-public:
-    explicit IFactoryResetInterface();
-    ~IFactoryResetInterface();
-};
-
-class NS final : public ServiceFramework<NS> {
-public:
-    explicit NS(const char* name);
-    ~NS();
-
-    std::shared_ptr<IApplicationManagerInterface> GetApplicationManagerInterface() const;
-
-private:
-    template <typename T>
-    void PushInterface(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NS, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<T>();
-    }
-
-    template <typename T>
-    std::shared_ptr<T> GetInterface() const {
-        static_assert(std::is_base_of_v<Kernel::SessionRequestHandler, T>,
-                      "Not a base of ServiceFrameworkBase");
-
-        return std::make_shared<T>();
-    }
-};
-
 /// Registers all NS services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 

src/core/hle/service/ns/ns_language.h

@@ -1,42 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-#include <optional>
-#include <string>
-#include "common/common_types.h"
-#include "core/hle/service/set/set.h"
-
-namespace Service::NS {
-/// This is nn::ns::detail::ApplicationLanguage
-enum class ApplicationLanguage : u8 {
-    AmericanEnglish = 0,
-    BritishEnglish,
-    Japanese,
-    French,
-    German,
-    LatinAmericanSpanish,
-    Spanish,
-    Italian,
-    Dutch,
-    CanadianFrench,
-    Portuguese,
-    Russian,
-    Korean,
-    TraditionalChinese,
-    SimplifiedChinese,
-    Count
-};
-using ApplicationLanguagePriorityList =
-    const std::array<ApplicationLanguage, static_cast<std::size_t>(ApplicationLanguage::Count)>;
-
-constexpr u32 GetSupportedLanguageFlag(const ApplicationLanguage lang) {
-    return 1U << static_cast<u32>(lang);
-}
-
-const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(ApplicationLanguage lang);
-std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
-    Service::Set::LanguageCode language_code);
-std::optional<Service::Set::LanguageCode> ConvertToLanguageCode(ApplicationLanguage lang);
-} // namespace Service::NS

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp

@@ -185,8 +185,7 @@ u32 nvhost_ctrl_gpu::GetGpuTime(const std::vector<u8>& input, std::vector<u8>& o
 
     IoctlGetGpuTime params{};
     std::memcpy(&params, input.data(), input.size());
-    const auto ns = Core::Timing::CyclesToNs(Core::System::GetInstance().CoreTiming().GetTicks());
-    params.gpu_time = static_cast<u64_le>(ns.count());
+    params.gpu_time = Core::Timing::cyclesToNs(Core::System::GetInstance().CoreTiming().GetTicks());
     std::memcpy(output.data(), &params, output.size());
     return 0;
 }

src/core/hle/service/time/time.cpp

@@ -108,9 +108,8 @@ private:
         LOG_DEBUG(Service_Time, "called");
 
         const auto& core_timing = Core::System::GetInstance().CoreTiming();
-        const auto ms = Core::Timing::CyclesToMs(core_timing.GetTicks());
-        const SteadyClockTimePoint steady_clock_time_point{static_cast<u64_le>(ms.count() / 1000),
-                                                           {}};
+        const SteadyClockTimePoint steady_clock_time_point{
+            Core::Timing::cyclesToMs(core_timing.GetTicks()) / 1000};
         IPC::ResponseBuilder rb{ctx, (sizeof(SteadyClockTimePoint) / 4) + 2};
         rb.Push(RESULT_SUCCESS);
         rb.PushRaw(steady_clock_time_point);
@@ -285,8 +284,8 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
     }
 
     const auto& core_timing = Core::System::GetInstance().CoreTiming();
-    const auto ms = Core::Timing::CyclesToMs(core_timing.GetTicks());
-    const SteadyClockTimePoint steady_clock_time_point{static_cast<u64_le>(ms.count() / 1000), {}};
+    const SteadyClockTimePoint steady_clock_time_point{
+        Core::Timing::cyclesToMs(core_timing.GetTicks()) / 1000, {}};
 
     CalendarTime calendar_time{};
     calendar_time.year = tm->tm_year + 1900;

src/core/loader/loader.h

@@ -153,6 +153,17 @@ public:
      */
     virtual LoadResult Load(Kernel::Process& process) = 0;
 
+    /**
+     * Loads the system mode that this application needs.
+     * This function defaults to 2 (96MB allocated to the application) if it can't read the
+     * information.
+     * @returns A pair with the optional system mode, and and the status.
+     */
+    virtual std::pair<std::optional<u32>, ResultStatus> LoadKernelSystemMode() {
+        // 96MB allocated to the application.
+        return std::make_pair(2, ResultStatus::Success);
+    }
+
     /**
      * Get the code (typically .code section) of the application
      * @param buffer Reference to buffer to store data

src/core/settings.cpp

@@ -90,7 +90,6 @@ void LogSettings() {
     LogSetting("Renderer_UseResolutionFactor", Settings::values.resolution_factor);
     LogSetting("Renderer_UseFrameLimit", Settings::values.use_frame_limit);
     LogSetting("Renderer_FrameLimit", Settings::values.frame_limit);
-    LogSetting("Renderer_UseCompatibilityProfile", Settings::values.use_compatibility_profile);
     LogSetting("Renderer_UseDiskShaderCache", Settings::values.use_disk_shader_cache);
     LogSetting("Renderer_UseAccurateGpuEmulation", Settings::values.use_accurate_gpu_emulation);
     LogSetting("Renderer_UseAsynchronousGpuEmulation",

src/core/settings.h

@@ -390,7 +390,6 @@ struct Values {
     float resolution_factor;
     bool use_frame_limit;
     u16 frame_limit;
-    bool use_compatibility_profile;
     bool use_disk_shader_cache;
     bool use_accurate_gpu_emulation;
     bool use_asynchronous_gpu_emulation;

src/core/telemetry_session.cpp

@@ -12,6 +12,7 @@
 #include "common/file_util.h"
 #include "common/logging/log.h"
 
+#include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/loader/loader.h"
@@ -100,30 +101,7 @@ bool VerifyLogin(const std::string& username, const std::string& token) {
 #endif
 }
 
-TelemetrySession::TelemetrySession() = default;
-
-TelemetrySession::~TelemetrySession() {
-    // Log one-time session end information
-    const s64 shutdown_time{std::chrono::duration_cast<std::chrono::milliseconds>(
-                                std::chrono::system_clock::now().time_since_epoch())
-                                .count()};
-    AddField(Telemetry::FieldType::Session, "Shutdown_Time", shutdown_time);
-
-#ifdef ENABLE_WEB_SERVICE
-    auto backend = std::make_unique<WebService::TelemetryJson>(
-        Settings::values.web_api_url, Settings::values.yuzu_username, Settings::values.yuzu_token);
-#else
-    auto backend = std::make_unique<Telemetry::NullVisitor>();
-#endif
-
-    // Complete the session, submitting to the web service backend if necessary
-    field_collection.Accept(*backend);
-    if (Settings::values.enable_telemetry) {
-        backend->Complete();
-    }
-}
-
-void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
+TelemetrySession::TelemetrySession() {
     // Log one-time top-level information
     AddField(Telemetry::FieldType::None, "TelemetryId", GetTelemetryId());
 
@@ -134,28 +112,26 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
     AddField(Telemetry::FieldType::Session, "Init_Time", init_time);
 
     u64 program_id{};
-    const Loader::ResultStatus res{app_loader.ReadProgramId(program_id)};
+    const Loader::ResultStatus res{System::GetInstance().GetAppLoader().ReadProgramId(program_id)};
     if (res == Loader::ResultStatus::Success) {
         const std::string formatted_program_id{fmt::format("{:016X}", program_id)};
         AddField(Telemetry::FieldType::Session, "ProgramId", formatted_program_id);
 
         std::string name;
-        app_loader.ReadTitle(name);
+        System::GetInstance().GetAppLoader().ReadTitle(name);
 
         if (name.empty()) {
             auto [nacp, icon_file] = FileSys::PatchManager(program_id).GetControlMetadata();
-            if (nacp != nullptr) {
+            if (nacp != nullptr)
                 name = nacp->GetApplicationName();
-            }
         }
 
-        if (!name.empty()) {
+        if (!name.empty())
             AddField(Telemetry::FieldType::Session, "ProgramName", name);
-        }
     }
 
     AddField(Telemetry::FieldType::Session, "ProgramFormat",
-             static_cast<u8>(app_loader.GetFileType()));
+             static_cast<u8>(System::GetInstance().GetAppLoader().GetFileType()));
 
     // Log application information
     Telemetry::AppendBuildInfo(field_collection);
@@ -186,6 +162,27 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
              Settings::values.use_docked_mode);
 }
 
+TelemetrySession::~TelemetrySession() {
+    // Log one-time session end information
+    const s64 shutdown_time{std::chrono::duration_cast<std::chrono::milliseconds>(
+                                std::chrono::system_clock::now().time_since_epoch())
+                                .count()};
+    AddField(Telemetry::FieldType::Session, "Shutdown_Time", shutdown_time);
+
+#ifdef ENABLE_WEB_SERVICE
+    auto backend = std::make_unique<WebService::TelemetryJson>(
+        Settings::values.web_api_url, Settings::values.yuzu_username, Settings::values.yuzu_token);
+#else
+    auto backend = std::make_unique<Telemetry::NullVisitor>();
+#endif
+
+    // Complete the session, submitting to web service if necessary
+    field_collection.Accept(*backend);
+    if (Settings::values.enable_telemetry)
+        backend->Complete();
+    backend = nullptr;
+}
+
 bool TelemetrySession::SubmitTestcase() {
 #ifdef ENABLE_WEB_SERVICE
     auto backend = std::make_unique<WebService::TelemetryJson>(

src/core/telemetry_session.h

@@ -4,13 +4,10 @@
 
 #pragma once
 
+#include <memory>
 #include <string>
 #include "common/telemetry.h"
 
-namespace Loader {
-class AppLoader;
-}
-
 namespace Core {
 
 /**
@@ -18,33 +15,11 @@ namespace Core {
  * session, logging any one-time fields. Interfaces with the telemetry backend used for submitting
  * data to the web service. Submits session data on close.
  */
-class TelemetrySession {
+class TelemetrySession : NonCopyable {
 public:
-    explicit TelemetrySession();
+    TelemetrySession();
     ~TelemetrySession();
 
-    TelemetrySession(const TelemetrySession&) = delete;
-    TelemetrySession& operator=(const TelemetrySession&) = delete;
-
-    TelemetrySession(TelemetrySession&&) = delete;
-    TelemetrySession& operator=(TelemetrySession&&) = delete;
-
-    /**
-     * Adds the initial telemetry info necessary when starting up a title.
-     *
-     * This includes information such as:
-     *   - Telemetry ID
-     *   - Initialization time
-     *   - Title ID
-     *   - Title name
-     *   - Title file format
-     *   - Miscellaneous settings values.
-     *
-     * @param app_loader The application loader to use to retrieve
-     *                   title-specific information.
-     */
-    void AddInitialInfo(Loader::AppLoader& app_loader);
-
     /**
      * Wrapper around the Telemetry::FieldCollection::AddField method.
      * @param type Type of the field to add.

src/input_common/sdl/sdl.h

@@ -6,8 +6,15 @@
 
 #include <memory>
 #include <vector>
+#include "core/frontend/input.h"
 #include "input_common/main.h"
 
+union SDL_Event;
+
+namespace Common {
+class ParamPackage;
+} // namespace Common
+
 namespace InputCommon::Polling {
 class DevicePoller;
 enum class DeviceType;

src/input_common/sdl/sdl_impl.cpp

@@ -6,6 +6,7 @@
 #include <atomic>
 #include <cmath>
 #include <functional>
+#include <iterator>
 #include <mutex>
 #include <string>
 #include <thread>
@@ -14,6 +15,7 @@
 #include <utility>
 #include <vector>
 #include <SDL.h>
+#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/math_util.h"
 #include "common/param_package.h"
@@ -21,10 +23,12 @@
 #include "core/frontend/input.h"
 #include "input_common/sdl/sdl_impl.h"
 
-namespace InputCommon::SDL {
+namespace InputCommon {
+
+namespace SDL {
 
 static std::string GetGUID(SDL_Joystick* joystick) {
-    const SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
+    SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
     char guid_str[33];
     SDL_JoystickGetGUIDString(guid, guid_str, sizeof(guid_str));
     return guid_str;
@@ -33,27 +37,26 @@ static std::string GetGUID(SDL_Joystick* joystick) {
 /// Creates a ParamPackage from an SDL_Event that can directly be used to create a ButtonDevice
 static Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event);
 
-static int SDLEventWatcher(void* user_data, SDL_Event* event) {
-    auto* const sdl_state = static_cast<SDLState*>(user_data);
-
+static int SDLEventWatcher(void* userdata, SDL_Event* event) {
+    SDLState* sdl_state = reinterpret_cast<SDLState*>(userdata);
     // Don't handle the event if we are configuring
     if (sdl_state->polling) {
         sdl_state->event_queue.Push(*event);
     } else {
         sdl_state->HandleGameControllerEvent(*event);
     }
-
     return 0;
 }
 
 class SDLJoystick {
 public:
-    SDLJoystick(std::string guid_, int port_, SDL_Joystick* joystick)
-        : guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, &SDL_JoystickClose} {}
+    SDLJoystick(std::string guid_, int port_, SDL_Joystick* joystick,
+                decltype(&SDL_JoystickClose) deleter = &SDL_JoystickClose)
+        : guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, deleter} {}
 
     void SetButton(int button, bool value) {
         std::lock_guard lock{mutex};
-        state.buttons.insert_or_assign(button, value);
+        state.buttons[button] = value;
     }
 
     bool GetButton(int button) const {
@@ -63,7 +66,7 @@ public:
 
     void SetAxis(int axis, Sint16 value) {
         std::lock_guard lock{mutex};
-        state.axes.insert_or_assign(axis, value);
+        state.axes[axis] = value;
     }
 
     float GetAxis(int axis) const {
@@ -90,7 +93,7 @@ public:
 
     void SetHat(int hat, Uint8 direction) {
         std::lock_guard lock{mutex};
-        state.hats.insert_or_assign(hat, direction);
+        state.hats[hat] = direction;
     }
 
     bool GetHatDirection(int hat, Uint8 direction) const {
@@ -115,8 +118,10 @@ public:
         return sdl_joystick.get();
     }
 
-    void SetSDLJoystick(SDL_Joystick* joystick) {
-        sdl_joystick.reset(joystick);
+    void SetSDLJoystick(SDL_Joystick* joystick,
+                        decltype(&SDL_JoystickClose) deleter = &SDL_JoystickClose) {
+        sdl_joystick =
+            std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)>(joystick, deleter);
     }
 
 private:
@@ -131,57 +136,59 @@ private:
     mutable std::mutex mutex;
 };
 
+/**
+ * Get the nth joystick with the corresponding GUID
+ */
 std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickByGUID(const std::string& guid, int port) {
     std::lock_guard lock{joystick_map_mutex};
     const auto it = joystick_map.find(guid);
     if (it != joystick_map.end()) {
-        while (it->second.size() <= static_cast<std::size_t>(port)) {
-            auto joystick =
-                std::make_shared<SDLJoystick>(guid, static_cast<int>(it->second.size()), nullptr);
+        while (it->second.size() <= port) {
+            auto joystick = std::make_shared<SDLJoystick>(guid, it->second.size(), nullptr,
+                                                          [](SDL_Joystick*) {});
             it->second.emplace_back(std::move(joystick));
         }
         return it->second[port];
     }
-    auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr);
+    auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr, [](SDL_Joystick*) {});
     return joystick_map[guid].emplace_back(std::move(joystick));
 }
 
+/**
+ * Check how many identical joysticks (by guid) were connected before the one with sdl_id and so tie
+ * it to a SDLJoystick with the same guid and that port
+ */
 std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickBySDLID(SDL_JoystickID sdl_id) {
     auto sdl_joystick = SDL_JoystickFromInstanceID(sdl_id);
     const std::string guid = GetGUID(sdl_joystick);
 
     std::lock_guard lock{joystick_map_mutex};
-    const auto map_it = joystick_map.find(guid);
+    auto map_it = joystick_map.find(guid);
     if (map_it != joystick_map.end()) {
-        const auto vec_it =
-            std::find_if(map_it->second.begin(), map_it->second.end(),
-                         [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
-                             return sdl_joystick == joystick->GetSDLJoystick();
-                         });
+        auto vec_it = std::find_if(map_it->second.begin(), map_it->second.end(),
+                                   [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
+                                       return sdl_joystick == joystick->GetSDLJoystick();
+                                   });
         if (vec_it != map_it->second.end()) {
             // This is the common case: There is already an existing SDL_Joystick maped to a
             // SDLJoystick. return the SDLJoystick
             return *vec_it;
         }
-
         // Search for a SDLJoystick without a mapped SDL_Joystick...
-        const auto nullptr_it = std::find_if(map_it->second.begin(), map_it->second.end(),
-                                             [](const std::shared_ptr<SDLJoystick>& joystick) {
-                                                 return !joystick->GetSDLJoystick();
-                                             });
+        auto nullptr_it = std::find_if(map_it->second.begin(), map_it->second.end(),
+                                       [](const std::shared_ptr<SDLJoystick>& joystick) {
+                                           return !joystick->GetSDLJoystick();
+                                       });
         if (nullptr_it != map_it->second.end()) {
             // ... and map it
             (*nullptr_it)->SetSDLJoystick(sdl_joystick);
             return *nullptr_it;
         }
-
         // There is no SDLJoystick without a mapped SDL_Joystick
         // Create a new SDLJoystick
-        const int port = static_cast<int>(map_it->second.size());
-        auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick);
+        auto joystick = std::make_shared<SDLJoystick>(guid, map_it->second.size(), sdl_joystick);
         return map_it->second.emplace_back(std::move(joystick));
     }
-
     auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick);
     return joystick_map[guid].emplace_back(std::move(joystick));
 }
@@ -208,19 +215,17 @@ void SDLState::InitJoystick(int joystick_index) {
         (*it)->SetSDLJoystick(sdl_joystick);
         return;
     }
-    const int port = static_cast<int>(joystick_guid_list.size());
-    auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick);
+    auto joystick = std::make_shared<SDLJoystick>(guid, joystick_guid_list.size(), sdl_joystick);
     joystick_guid_list.emplace_back(std::move(joystick));
 }
 
 void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
-    const std::string guid = GetGUID(sdl_joystick);
-
+    std::string guid = GetGUID(sdl_joystick);
     std::shared_ptr<SDLJoystick> joystick;
     {
         std::lock_guard lock{joystick_map_mutex};
         // This call to guid is safe since the joystick is guaranteed to be in the map
-        const auto& joystick_guid_list = joystick_map[guid];
+        auto& joystick_guid_list = joystick_map[guid];
         const auto joystick_it =
             std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
                          [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
@@ -228,10 +233,9 @@ void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
                          });
         joystick = *joystick_it;
     }
-
-    // Destruct SDL_Joystick outside the lock guard because SDL can internally call the
-    // event callback which locks the mutex again.
-    joystick->SetSDLJoystick(nullptr);
+    // Destruct SDL_Joystick outside the lock guard because SDL can internally call event calback
+    // which locks the mutex again
+    joystick->SetSDLJoystick(nullptr, [](SDL_Joystick*) {});
 }
 
 void SDLState::HandleGameControllerEvent(const SDL_Event& event) {
@@ -313,10 +317,9 @@ public:
           trigger_if_greater(trigger_if_greater_) {}
 
     bool GetStatus() const override {
-        const float axis_value = joystick->GetAxis(axis);
-        if (trigger_if_greater) {
+        float axis_value = joystick->GetAxis(axis);
+        if (trigger_if_greater)
             return axis_value > threshold;
-        }
         return axis_value < threshold;
     }
 
@@ -441,7 +444,7 @@ public:
         const int port = params.Get("port", 0);
         const int axis_x = params.Get("axis_x", 0);
         const int axis_y = params.Get("axis_y", 1);
-        const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
+        float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
 
         auto joystick = state.GetSDLJoystickByGUID(guid, port);
 
@@ -467,7 +470,7 @@ SDLState::SDLState() {
         return;
     }
     if (SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1") == SDL_FALSE) {
-        LOG_ERROR(Input, "Failed to set hint for background events with: {}", SDL_GetError());
+        LOG_ERROR(Input, "Failed to set Hint for background events", SDL_GetError());
     }
 
     SDL_AddEventWatch(&SDLEventWatcher, this);
@@ -504,12 +507,12 @@ SDLState::~SDLState() {
     }
 }
 
-static Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event) {
+Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event) {
     Common::ParamPackage params({{"engine", "sdl"}});
 
     switch (event.type) {
     case SDL_JOYAXISMOTION: {
-        const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+        auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
         params.Set("port", joystick->GetPort());
         params.Set("guid", joystick->GetGUID());
         params.Set("axis", event.jaxis.axis);
@@ -523,14 +526,14 @@ static Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const
         break;
     }
     case SDL_JOYBUTTONUP: {
-        const auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which);
+        auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which);
         params.Set("port", joystick->GetPort());
         params.Set("guid", joystick->GetGUID());
         params.Set("button", event.jbutton.button);
         break;
     }
     case SDL_JOYHATMOTION: {
-        const auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which);
+        auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which);
         params.Set("port", joystick->GetPort());
         params.Set("guid", joystick->GetGUID());
         params.Set("hat", event.jhat.hat);
@@ -604,8 +607,8 @@ public:
         SDLPoller::Start();
 
         // Reset stored axes
-        analog_x_axis = -1;
-        analog_y_axis = -1;
+        analog_xaxis = -1;
+        analog_yaxis = -1;
         analog_axes_joystick = -1;
     }
 
@@ -617,25 +620,25 @@ public:
             }
             // An analog device needs two axes, so we need to store the axis for later and wait for
             // a second SDL event. The axes also must be from the same joystick.
-            const int axis = event.jaxis.axis;
-            if (analog_x_axis == -1) {
-                analog_x_axis = axis;
+            int axis = event.jaxis.axis;
+            if (analog_xaxis == -1) {
+                analog_xaxis = axis;
                 analog_axes_joystick = event.jaxis.which;
-            } else if (analog_y_axis == -1 && analog_x_axis != axis &&
+            } else if (analog_yaxis == -1 && analog_xaxis != axis &&
                        analog_axes_joystick == event.jaxis.which) {
-                analog_y_axis = axis;
+                analog_yaxis = axis;
             }
         }
         Common::ParamPackage params;
-        if (analog_x_axis != -1 && analog_y_axis != -1) {
-            const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+        if (analog_xaxis != -1 && analog_yaxis != -1) {
+            auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
             params.Set("engine", "sdl");
             params.Set("port", joystick->GetPort());
             params.Set("guid", joystick->GetGUID());
-            params.Set("axis_x", analog_x_axis);
-            params.Set("axis_y", analog_y_axis);
-            analog_x_axis = -1;
-            analog_y_axis = -1;
+            params.Set("axis_x", analog_xaxis);
+            params.Set("axis_y", analog_yaxis);
+            analog_xaxis = -1;
+            analog_yaxis = -1;
             analog_axes_joystick = -1;
             return params;
         }
@@ -643,8 +646,8 @@ public:
     }
 
 private:
-    int analog_x_axis = -1;
-    int analog_y_axis = -1;
+    int analog_xaxis = -1;
+    int analog_yaxis = -1;
     SDL_JoystickID analog_axes_joystick = -1;
 };
 } // namespace Polling
@@ -664,4 +667,5 @@ SDLState::Pollers SDLState::GetPollers(InputCommon::Polling::DeviceType type) {
     return pollers;
 }
 
-} // namespace InputCommon::SDL
+} // namespace SDL
+} // namespace InputCommon

src/input_common/sdl/sdl_impl.h

@@ -6,10 +6,7 @@
 
 #include <atomic>
 #include <memory>
-#include <mutex>
 #include <thread>
-#include <unordered_map>
-#include "common/common_types.h"
 #include "common/threadsafe_queue.h"
 #include "input_common/sdl/sdl.h"
 
@@ -19,9 +16,9 @@ using SDL_JoystickID = s32;
 
 namespace InputCommon::SDL {
 
-class SDLAnalogFactory;
-class SDLButtonFactory;
 class SDLJoystick;
+class SDLButtonFactory;
+class SDLAnalogFactory;
 
 class SDLState : public State {
 public:
@@ -34,13 +31,7 @@ public:
     /// Handle SDL_Events for joysticks from SDL_PollEvent
     void HandleGameControllerEvent(const SDL_Event& event);
 
-    /// Get the nth joystick with the corresponding GUID
     std::shared_ptr<SDLJoystick> GetSDLJoystickBySDLID(SDL_JoystickID sdl_id);
-
-    /**
-     * Check how many identical joysticks (by guid) were connected before the one with sdl_id and so
-     * tie it to a SDLJoystick with the same guid and that port
-     */
     std::shared_ptr<SDLJoystick> GetSDLJoystickByGUID(const std::string& guid, int port);
 
     /// Get all DevicePoller that use the SDL backend for a specific device type

src/video_core/CMakeLists.txt

@@ -42,8 +42,6 @@ add_library(video_core STATIC
     renderer_opengl/gl_device.h
     renderer_opengl/gl_global_cache.cpp
     renderer_opengl/gl_global_cache.h
-    renderer_opengl/gl_primitive_assembler.cpp
-    renderer_opengl/gl_primitive_assembler.h
     renderer_opengl/gl_rasterizer.cpp
     renderer_opengl/gl_rasterizer.h
     renderer_opengl/gl_rasterizer_cache.cpp

src/video_core/engines/shader_bytecode.h

@@ -1663,7 +1663,6 @@ private:
             INST("111000100100----", Id::BRA, Type::Flow, "BRA"),
             INST("1111000011111---", Id::SYNC, Type::Flow, "SYNC"),
             INST("111000110100---", Id::BRK, Type::Flow, "BRK"),
-            INST("111000110000----", Id::EXIT, Type::Flow, "EXIT"),
             INST("1111000011110---", Id::DEPBAR, Type::Synch, "DEPBAR"),
             INST("1110111111011---", Id::LD_A, Type::Memory, "LD_A"),
             INST("1110111101001---", Id::LD_S, Type::Memory, "LD_S"),
@@ -1687,6 +1686,7 @@ private:
             INST("1101111100------", Id::TLD4S, Type::Texture, "TLD4S"),
             INST("110111110110----", Id::TMML_B, Type::Texture, "TMML_B"),
             INST("1101111101011---", Id::TMML, Type::Texture, "TMML"),
+            INST("111000110000----", Id::EXIT, Type::Trivial, "EXIT"),
             INST("11100000--------", Id::IPA, Type::Trivial, "IPA"),
             INST("1111101111100---", Id::OUT_R, Type::Trivial, "OUT_R"),
             INST("1110111111010---", Id::ISBERD, Type::Trivial, "ISBERD"),

src/video_core/gpu_thread.cpp

@@ -75,7 +75,7 @@ void ThreadManager::StartThread(VideoCore::RendererBase& renderer, Tegra::DmaPus
 
 void ThreadManager::SubmitList(Tegra::CommandList&& entries) {
     const u64 fence{PushCommand(SubmitListCommand(std::move(entries)))};
-    const s64 synchronization_ticks{Core::Timing::usToCycles(std::chrono::microseconds{9000})};
+    const s64 synchronization_ticks{Core::Timing::usToCycles(9000)};
     system.CoreTiming().ScheduleEvent(synchronization_ticks, synchronization_event, fence);
 }
 

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -71,16 +71,6 @@ GLintptr OGLBufferCache::UploadHostMemory(const void* raw_pointer, std::size_t s
     return uploaded_offset;
 }
 
-std::tuple<u8*, GLintptr> OGLBufferCache::ReserveMemory(std::size_t size, std::size_t alignment) {
-    AlignBuffer(alignment);
-    u8* const uploaded_ptr = buffer_ptr;
-    const GLintptr uploaded_offset = buffer_offset;
-
-    buffer_ptr += size;
-    buffer_offset += size;
-    return std::make_tuple(uploaded_ptr, uploaded_offset);
-}
-
 bool OGLBufferCache::Map(std::size_t max_size) {
     bool invalidate;
     std::tie(buffer_ptr, buffer_offset_base, invalidate) =

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -61,9 +61,6 @@ public:
     /// Uploads from a host memory. Returns host's buffer offset where it's been allocated.
     GLintptr UploadHostMemory(const void* raw_pointer, std::size_t size, std::size_t alignment = 4);
 
-    /// Reserves memory to be used by host's CPU. Returns mapped address and offset.
-    std::tuple<u8*, GLintptr> ReserveMemory(std::size_t size, std::size_t alignment = 4);
-
     bool Map(std::size_t max_size);
     void Unmap();
 

src/video_core/renderer_opengl/gl_device.cpp

@@ -2,14 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
 #include <cstddef>
 #include <glad/glad.h>
 
 #include "common/logging/log.h"
-#include "common/scope_exit.h"
 #include "video_core/renderer_opengl/gl_device.h"
-#include "video_core/renderer_opengl/gl_resource_manager.h"
 
 namespace OpenGL {
 
@@ -27,7 +24,6 @@ Device::Device() {
     max_vertex_attributes = GetInteger<u32>(GL_MAX_VERTEX_ATTRIBS);
     max_varyings = GetInteger<u32>(GL_MAX_VARYING_VECTORS);
     has_variable_aoffi = TestVariableAoffi();
-    has_component_indexing_bug = TestComponentIndexingBug();
 }
 
 Device::Device(std::nullptr_t) {
@@ -35,7 +31,6 @@ Device::Device(std::nullptr_t) {
     max_vertex_attributes = 16;
     max_varyings = 15;
     has_variable_aoffi = true;
-    has_component_indexing_bug = false;
 }
 
 bool Device::TestVariableAoffi() {
@@ -57,53 +52,4 @@ void main() {
     return supported;
 }
 
-bool Device::TestComponentIndexingBug() {
-    constexpr char log_message[] = "Renderer_ComponentIndexingBug: {}";
-    const GLchar* COMPONENT_TEST = R"(#version 430 core
-layout (std430, binding = 0) buffer OutputBuffer {
-    uint output_value;
-};
-layout (std140, binding = 0) uniform InputBuffer {
-    uvec4 input_value[4096];
-};
-layout (location = 0) uniform uint idx;
-void main() {
-    output_value = input_value[idx >> 2][idx & 3];
-})";
-    const GLuint shader{glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &COMPONENT_TEST)};
-    SCOPE_EXIT({ glDeleteProgram(shader); });
-    glUseProgram(shader);
-
-    OGLVertexArray vao;
-    vao.Create();
-    glBindVertexArray(vao.handle);
-
-    constexpr std::array<GLuint, 8> values{0, 0, 0, 0, 0x1236327, 0x985482, 0x872753, 0x2378432};
-    OGLBuffer ubo;
-    ubo.Create();
-    glNamedBufferData(ubo.handle, sizeof(values), values.data(), GL_STATIC_DRAW);
-    glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo.handle);
-
-    OGLBuffer ssbo;
-    ssbo.Create();
-    glNamedBufferStorage(ssbo.handle, sizeof(GLuint), nullptr, GL_CLIENT_STORAGE_BIT);
-
-    for (GLuint index = 4; index < 8; ++index) {
-        glInvalidateBufferData(ssbo.handle);
-        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, ssbo.handle);
-
-        glProgramUniform1ui(shader, 0, index);
-        glDrawArrays(GL_POINTS, 0, 1);
-
-        GLuint result;
-        glGetNamedBufferSubData(ssbo.handle, 0, sizeof(result), &result);
-        if (result != values.at(index)) {
-            LOG_INFO(Render_OpenGL, log_message, true);
-            return true;
-        }
-    }
-    LOG_INFO(Render_OpenGL, log_message, false);
-    return false;
-}
-
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_device.h

@@ -30,19 +30,13 @@ public:
         return has_variable_aoffi;
     }
 
-    bool HasComponentIndexingBug() const {
-        return has_component_indexing_bug;
-    }
-
 private:
     static bool TestVariableAoffi();
-    static bool TestComponentIndexingBug();
 
     std::size_t uniform_buffer_alignment{};
     u32 max_vertex_attributes{};
     u32 max_varyings{};
     bool has_variable_aoffi{};
-    bool has_component_indexing_bug{};
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_primitive_assembler.cpp

@@ -1,63 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <array>
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "core/core.h"
-#include "video_core/memory_manager.h"
-#include "video_core/renderer_opengl/gl_buffer_cache.h"
-#include "video_core/renderer_opengl/gl_primitive_assembler.h"
-
-namespace OpenGL {
-
-constexpr u32 TRIANGLES_PER_QUAD = 6;
-constexpr std::array<u32, TRIANGLES_PER_QUAD> QUAD_MAP = {0, 1, 2, 0, 2, 3};
-
-PrimitiveAssembler::PrimitiveAssembler(OGLBufferCache& buffer_cache) : buffer_cache(buffer_cache) {}
-
-PrimitiveAssembler::~PrimitiveAssembler() = default;
-
-std::size_t PrimitiveAssembler::CalculateQuadSize(u32 count) const {
-    ASSERT_MSG(count % 4 == 0, "Quad count is expected to be a multiple of 4");
-    return (count / 4) * TRIANGLES_PER_QUAD * sizeof(GLuint);
-}
-
-GLintptr PrimitiveAssembler::MakeQuadArray(u32 first, u32 count) {
-    const std::size_t size{CalculateQuadSize(count)};
-    auto [dst_pointer, index_offset] = buffer_cache.ReserveMemory(size);
-
-    for (u32 primitive = 0; primitive < count / 4; ++primitive) {
-        for (u32 i = 0; i < TRIANGLES_PER_QUAD; ++i) {
-            const u32 index = first + primitive * 4 + QUAD_MAP[i];
-            std::memcpy(dst_pointer, &index, sizeof(index));
-            dst_pointer += sizeof(index);
-        }
-    }
-
-    return index_offset;
-}
-
-GLintptr PrimitiveAssembler::MakeQuadIndexed(GPUVAddr gpu_addr, std::size_t index_size, u32 count) {
-    const std::size_t map_size{CalculateQuadSize(count)};
-    auto [dst_pointer, index_offset] = buffer_cache.ReserveMemory(map_size);
-
-    auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager();
-    const u8* source{memory_manager.GetPointer(gpu_addr)};
-
-    for (u32 primitive = 0; primitive < count / 4; ++primitive) {
-        for (std::size_t i = 0; i < TRIANGLES_PER_QUAD; ++i) {
-            const u32 index = primitive * 4 + QUAD_MAP[i];
-            const u8* src_offset = source + (index * index_size);
-
-            std::memcpy(dst_pointer, src_offset, index_size);
-            dst_pointer += index_size;
-        }
-    }
-
-    return index_offset;
-}
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_primitive_assembler.h

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <glad/glad.h>
-
-#include "common/common_types.h"
-
-namespace OpenGL {
-
-class OGLBufferCache;
-
-class PrimitiveAssembler {
-public:
-    explicit PrimitiveAssembler(OGLBufferCache& buffer_cache);
-    ~PrimitiveAssembler();
-
-    /// Calculates the size required by MakeQuadArray and MakeQuadIndexed.
-    std::size_t CalculateQuadSize(u32 count) const;
-
-    GLintptr MakeQuadArray(u32 first, u32 count);
-
-    GLintptr MakeQuadIndexed(GPUVAddr gpu_addr, std::size_t index_size, u32 count);
-
-private:
-    OGLBufferCache& buffer_cache;
-};
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -246,29 +246,6 @@ DrawParameters RasterizerOpenGL::SetupDraw() {
     DrawParameters params{};
     params.current_instance = gpu.state.current_instance;
 
-    if (regs.draw.topology == Maxwell::PrimitiveTopology::Quads) {
-        MICROPROFILE_SCOPE(OpenGL_PrimitiveAssembly);
-
-        params.use_indexed = true;
-        params.primitive_mode = GL_TRIANGLES;
-
-        if (is_indexed) {
-            params.index_format = MaxwellToGL::IndexFormat(regs.index_array.format);
-            params.count = (regs.index_array.count / 4) * 6;
-            params.index_buffer_offset = primitive_assembler.MakeQuadIndexed(
-                regs.index_array.IndexStart(), regs.index_array.FormatSizeInBytes(),
-                regs.index_array.count);
-            params.base_vertex = static_cast<GLint>(regs.vb_element_base);
-        } else {
-            // MakeQuadArray always generates u32 indexes
-            params.index_format = GL_UNSIGNED_INT;
-            params.count = (regs.vertex_buffer.count / 4) * 6;
-            params.index_buffer_offset = primitive_assembler.MakeQuadArray(
-                regs.vertex_buffer.first, regs.vertex_buffer.count);
-        }
-        return params;
-    }
-
     params.use_indexed = is_indexed;
     params.primitive_mode = MaxwellToGL::PrimitiveTopology(regs.draw.topology);
 
@@ -686,30 +663,19 @@ void RasterizerOpenGL::DrawArrays() {
     SyncCullMode();
     SyncPrimitiveRestart();
     SyncScissorTest(state);
-    // Alpha Testing is synced on shaders.
     SyncTransformFeedback();
     SyncPointState();
-    CheckAlphaTests();
     SyncPolygonOffset();
-    // TODO(bunnei): Sync framebuffer_scale uniform here
-    // TODO(bunnei): Sync scissorbox uniform(s) here
+    SyncAlphaTest();
 
     // Draw the vertex batch
     const bool is_indexed = accelerate_draw == AccelDraw::Indexed;
 
     std::size_t buffer_size = CalculateVertexArraysSize();
 
-    // Add space for index buffer (keeping in mind non-core primitives)
-    switch (regs.draw.topology) {
-    case Maxwell::PrimitiveTopology::Quads:
-        buffer_size = Common::AlignUp(buffer_size, 4) +
-                      primitive_assembler.CalculateQuadSize(regs.vertex_buffer.count);
-        break;
-    default:
-        if (is_indexed) {
-            buffer_size = Common::AlignUp(buffer_size, 4) + CalculateIndexBufferSize();
-        }
-        break;
+    // Add space for index buffer
+    if (is_indexed) {
+        buffer_size = Common::AlignUp(buffer_size, 4) + CalculateIndexBufferSize();
     }
 
     // Uniform space for the 5 shader stages
@@ -1152,10 +1118,17 @@ void RasterizerOpenGL::SyncPolygonOffset() {
     state.polygon_offset.clamp = regs.polygon_offset_clamp;
 }
 
-void RasterizerOpenGL::CheckAlphaTests() {
+void RasterizerOpenGL::SyncAlphaTest() {
     const auto& regs = system.GPU().Maxwell3D().regs;
     UNIMPLEMENTED_IF_MSG(regs.alpha_test_enabled != 0 && regs.rt_control.count > 1,
                          "Alpha Testing is enabled with more than one rendertarget");
+
+    state.alpha_test.enabled = regs.alpha_test_enabled;
+    if (!state.alpha_test.enabled) {
+        return;
+    }
+    state.alpha_test.func = MaxwellToGL::ComparisonOp(regs.alpha_test_func);
+    state.alpha_test.ref = regs.alpha_test_ref;
 }
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -23,7 +23,6 @@
 #include "video_core/renderer_opengl/gl_buffer_cache.h"
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_global_cache.h"
-#include "video_core/renderer_opengl/gl_primitive_assembler.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_sampler_cache.h"
@@ -167,8 +166,8 @@ private:
     /// Syncs the polygon offsets
     void SyncPolygonOffset();
 
-    /// Check asserts for alpha testing.
-    void CheckAlphaTests();
+    /// Syncs the alpha test state to match the guest state
+    void SyncAlphaTest();
 
     /// Check for extension that are not strictly required
     /// but are needed for correct emulation
@@ -197,7 +196,6 @@ private:
 
     static constexpr std::size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
     OGLBufferCache buffer_cache;
-    PrimitiveAssembler primitive_assembler{buffer_cache};
 
     BindBuffersRangePushBuffer bind_ubo_pushbuffer{GL_UNIFORM_BUFFER};
     BindBuffersRangePushBuffer bind_ssbo_pushbuffer{GL_SHADER_STORAGE_BUFFER};

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -35,8 +35,8 @@ struct UnspecializedShader {
 namespace {
 
 /// Gets the address for the specified shader stage program
-GPUVAddr GetShaderAddress(Core::System& system, Maxwell::ShaderProgram program) {
-    const auto& gpu{system.GPU().Maxwell3D()};
+GPUVAddr GetShaderAddress(Maxwell::ShaderProgram program) {
+    const auto& gpu{Core::System::GetInstance().GPU().Maxwell3D()};
     const auto& shader_config{gpu.regs.shader_config[static_cast<std::size_t>(program)]};
     return gpu.regs.code_address.CodeAddress() + shader_config.offset;
 }
@@ -350,8 +350,7 @@ ShaderDiskCacheUsage CachedShader::GetUsage(GLenum primitive_mode,
 
 ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer, Core::System& system,
                                      Core::Frontend::EmuWindow& emu_window, const Device& device)
-    : RasterizerCache{rasterizer}, system{system}, emu_window{emu_window}, device{device},
-      disk_cache{system} {}
+    : RasterizerCache{rasterizer}, emu_window{emu_window}, device{device}, disk_cache{system} {}
 
 void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
                                       const VideoCore::DiskResourceLoadCallback& callback) {
@@ -547,45 +546,42 @@ std::unordered_map<u64, UnspecializedShader> ShaderCacheOpenGL::GenerateUnspecia
 }
 
 Shader ShaderCacheOpenGL::GetStageProgram(Maxwell::ShaderProgram program) {
-    if (!system.GPU().Maxwell3D().dirty_flags.shaders) {
-        return last_shaders[static_cast<std::size_t>(program)];
+    if (!Core::System::GetInstance().GPU().Maxwell3D().dirty_flags.shaders) {
+        return last_shaders[static_cast<u32>(program)];
     }
 
-    auto& memory_manager{system.GPU().MemoryManager()};
-    const GPUVAddr program_addr{GetShaderAddress(system, program)};
+    auto& memory_manager{Core::System::GetInstance().GPU().MemoryManager()};
+    const GPUVAddr program_addr{GetShaderAddress(program)};
 
     // Look up shader in the cache based on address
-    const auto host_ptr{memory_manager.GetPointer(program_addr)};
+    const auto& host_ptr{memory_manager.GetPointer(program_addr)};
     Shader shader{TryGet(host_ptr)};
-    if (shader) {
-        return last_shaders[static_cast<std::size_t>(program)] = shader;
+
+    if (!shader) {
+        // No shader found - create a new one
+        ProgramCode program_code{GetShaderCode(memory_manager, program_addr, host_ptr)};
+        ProgramCode program_code_b;
+        if (program == Maxwell::ShaderProgram::VertexA) {
+            const GPUVAddr program_addr_b{GetShaderAddress(Maxwell::ShaderProgram::VertexB)};
+            program_code_b = GetShaderCode(memory_manager, program_addr_b,
+                                           memory_manager.GetPointer(program_addr_b));
+        }
+        const u64 unique_identifier = GetUniqueIdentifier(program, program_code, program_code_b);
+        const VAddr cpu_addr{*memory_manager.GpuToCpuAddress(program_addr)};
+        const auto found = precompiled_shaders.find(unique_identifier);
+        if (found != precompiled_shaders.end()) {
+            shader =
+                std::make_shared<CachedShader>(cpu_addr, unique_identifier, program, disk_cache,
+                                               precompiled_programs, found->second, host_ptr);
+        } else {
+            shader = std::make_shared<CachedShader>(
+                device, cpu_addr, unique_identifier, program, disk_cache, precompiled_programs,
+                std::move(program_code), std::move(program_code_b), host_ptr);
+        }
+        Register(shader);
     }
 
-    // No shader found - create a new one
-    ProgramCode program_code{GetShaderCode(memory_manager, program_addr, host_ptr)};
-    ProgramCode program_code_b;
-    if (program == Maxwell::ShaderProgram::VertexA) {
-        const GPUVAddr program_addr_b{GetShaderAddress(system, Maxwell::ShaderProgram::VertexB)};
-        program_code_b = GetShaderCode(memory_manager, program_addr_b,
-                                       memory_manager.GetPointer(program_addr_b));
-    }
-
-    const u64 unique_identifier = GetUniqueIdentifier(program, program_code, program_code_b);
-    const VAddr cpu_addr{*memory_manager.GpuToCpuAddress(program_addr)};
-    const auto found = precompiled_shaders.find(unique_identifier);
-    if (found != precompiled_shaders.end()) {
-        // Create a shader from the cache
-        shader = std::make_shared<CachedShader>(cpu_addr, unique_identifier, program, disk_cache,
-                                                precompiled_programs, found->second, host_ptr);
-    } else {
-        // Create a shader from guest memory
-        shader = std::make_shared<CachedShader>(
-            device, cpu_addr, unique_identifier, program, disk_cache, precompiled_programs,
-            std::move(program_code), std::move(program_code_b), host_ptr);
-    }
-    Register(shader);
-
-    return last_shaders[static_cast<std::size_t>(program)] = shader;
+    return last_shaders[static_cast<u32>(program)] = shader;
 }
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -137,7 +137,6 @@ private:
     CachedProgram GeneratePrecompiledProgram(const ShaderDiskCacheDump& dump,
                                              const std::set<GLenum>& supported_formats);
 
-    Core::System& system;
     Core::Frontend::EmuWindow& emu_window;
     const Device& device;
     ShaderDiskCacheOpenGL disk_cache;

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -577,26 +577,9 @@ private:
             if (std::holds_alternative<OperationNode>(*offset)) {
                 // Indirect access
                 const std::string final_offset = code.GenerateTemporary();
-                code.AddLine("uint {} = ftou({}) >> 2;", final_offset, Visit(offset));
-
-                if (!device.HasComponentIndexingBug()) {
-                    return fmt::format("{}[{} >> 2][{} & 3]", GetConstBuffer(cbuf->GetIndex()),
-                                       final_offset, final_offset);
-                }
-
-                // AMD's proprietary GLSL compiler emits ill code for variable component access.
-                // To bypass this driver bug generate 4 ifs, one per each component.
-                const std::string pack = code.GenerateTemporary();
-                code.AddLine("vec4 {} = {}[{} >> 2];", pack, GetConstBuffer(cbuf->GetIndex()),
-                             final_offset);
-
-                const std::string result = code.GenerateTemporary();
-                code.AddLine("float {};", result);
-                for (u32 swizzle = 0; swizzle < 4; ++swizzle) {
-                    code.AddLine("if (({} & 3) == {}) {} = {}{};", final_offset, swizzle, result,
-                                 pack, GetSwizzle(swizzle));
-                }
-                return result;
+                code.AddLine("uint {} = (ftou({}) / 4);", final_offset, Visit(offset));
+                return fmt::format("{}[{} / 4][{} % 4]", GetConstBuffer(cbuf->GetIndex()),
+                                   final_offset, final_offset);
             }
 
             UNREACHABLE_MSG("Unmanaged offset node type");
@@ -1464,27 +1447,9 @@ private:
 
         UNIMPLEMENTED_IF_MSG(header.ps.omap.sample_mask != 0, "Sample mask write is unimplemented");
 
-        code.AddLine("if (alpha_test[0] != 0) {{");
-        ++code.scope;
-        // We start on the register containing the alpha value in the first RT.
-        u32 current_reg = 3;
-        for (u32 render_target = 0; render_target < Maxwell::NumRenderTargets; ++render_target) {
-            // TODO(Blinkhawk): verify the behavior of alpha testing on hardware when
-            // multiple render targets are used.
-            if (header.ps.IsColorComponentOutputEnabled(render_target, 0) ||
-                header.ps.IsColorComponentOutputEnabled(render_target, 1) ||
-                header.ps.IsColorComponentOutputEnabled(render_target, 2) ||
-                header.ps.IsColorComponentOutputEnabled(render_target, 3)) {
-                code.AddLine("if (!AlphaFunc({})) discard;", SafeGetRegister(current_reg));
-                current_reg += 4;
-            }
-        }
-        --code.scope;
-        code.AddLine("}}");
-
         // Write the color outputs using the data in the shader registers, disabled
         // rendertargets/components are skipped in the register assignment.
-        current_reg = 0;
+        u32 current_reg = 0;
         for (u32 render_target = 0; render_target < Maxwell::NumRenderTargets; ++render_target) {
             // TODO(Subv): Figure out how dual-source blending is configured in the Switch.
             for (u32 component = 0; component < 4; ++component) {

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -28,7 +28,6 @@ layout (location = 0) out vec4 position;
 layout (std140, binding = EMULATION_UBO_BINDING) uniform vs_config {
     vec4 viewport_flip;
     uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-    uvec4 alpha_test;
 };
 
 )";
@@ -91,7 +90,6 @@ layout (location = 0) out vec4 position;
 layout (std140, binding = EMULATION_UBO_BINDING) uniform gs_config {
     vec4 viewport_flip;
     uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-    uvec4 alpha_test;
 };
 
 )";
@@ -129,33 +127,8 @@ layout (location = 0) in noperspective vec4 position;
 layout (std140, binding = EMULATION_UBO_BINDING) uniform fs_config {
     vec4 viewport_flip;
     uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-    uvec4 alpha_test;
 };
 
-bool AlphaFunc(in float value) {
-    float ref = uintBitsToFloat(alpha_test[2]);
-    switch (alpha_test[1]) {
-        case 1:
-            return false;
-        case 2:
-            return value < ref;
-        case 3:
-            return value == ref;
-        case 4:
-            return value <= ref;
-        case 5:
-            return value > ref;
-        case 6:
-            return value != ref;
-        case 7:
-            return value >= ref;
-        case 8:
-            return true;
-        default:
-            return false;
-    }
-}
-
 )";
     const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET);
     ProgramResult program =

src/video_core/renderer_opengl/gl_shader_manager.cpp

@@ -48,17 +48,6 @@ void MaxwellUniformData::SetFromRegs(const Maxwell3D& maxwell, std::size_t shade
     viewport_flip[0] = regs.viewport_transform[0].scale_x < 0.0 ? -1.0f : 1.0f;
     viewport_flip[1] = regs.viewport_transform[0].scale_y < 0.0 ? -1.0f : 1.0f;
 
-    auto func{static_cast<u32>(regs.alpha_test_func)};
-    // Normalize the gl variants of opCompare to be the same as the normal variants
-    const u32 op_gl_variant_base = static_cast<u32>(Maxwell3D::Regs::ComparisonOp::Never);
-    if (func >= op_gl_variant_base) {
-        func = func - op_gl_variant_base + 1U;
-    }
-
-    alpha_test.enabled = regs.alpha_test_enabled;
-    alpha_test.func = func;
-    alpha_test.ref = regs.alpha_test_ref;
-
     instance_id = state.current_instance;
 
     // Assign in which stage the position has to be flipped

src/video_core/renderer_opengl/gl_shader_manager.h

@@ -27,14 +27,8 @@ struct MaxwellUniformData {
         GLuint flip_stage;
         GLfloat y_direction;
     };
-    struct alignas(16) {
-        GLuint enabled;
-        GLuint func;
-        GLfloat ref;
-        GLuint padding;
-    } alpha_test;
 };
-static_assert(sizeof(MaxwellUniformData) == 48, "MaxwellUniformData structure size is incorrect");
+static_assert(sizeof(MaxwellUniformData) == 32, "MaxwellUniformData structure size is incorrect");
 static_assert(sizeof(MaxwellUniformData) < 16384,
               "MaxwellUniformData structure must be less than 16kb as per the OpenGL spec");
 

src/video_core/renderer_opengl/gl_state.cpp

@@ -156,6 +156,10 @@ OpenGLState::OpenGLState() {
     polygon_offset.factor = 0.0f;
     polygon_offset.units = 0.0f;
     polygon_offset.clamp = 0.0f;
+
+    alpha_test.enabled = false;
+    alpha_test.func = GL_ALWAYS;
+    alpha_test.ref = 0.0f;
 }
 
 void OpenGLState::ApplyDefaultState() {
@@ -461,6 +465,14 @@ void OpenGLState::ApplyPolygonOffset() const {
     }
 }
 
+void OpenGLState::ApplyAlphaTest() const {
+    Enable(GL_ALPHA_TEST, cur_state.alpha_test.enabled, alpha_test.enabled);
+    if (UpdateTie(std::tie(cur_state.alpha_test.func, cur_state.alpha_test.ref),
+                  std::tie(alpha_test.func, alpha_test.ref))) {
+        glAlphaFunc(alpha_test.func, alpha_test.ref);
+    }
+}
+
 void OpenGLState::ApplyTextures() const {
     bool has_delta{};
     std::size_t first{};
@@ -533,6 +545,7 @@ void OpenGLState::Apply() const {
     ApplyTextures();
     ApplySamplers();
     ApplyPolygonOffset();
+    ApplyAlphaTest();
 }
 
 void OpenGLState::EmulateViewportWithScissor() {

src/video_core/renderer_opengl/gl_state.h

@@ -172,6 +172,12 @@ public:
         GLfloat clamp;
     } polygon_offset;
 
+    struct {
+        bool enabled; // GL_ALPHA_TEST
+        GLenum func;  // GL_ALPHA_TEST_FUNC
+        GLfloat ref;  // GL_ALPHA_TEST_REF
+    } alpha_test;
+
     std::array<bool, 8> clip_distance; // GL_CLIP_DISTANCE
 
     OpenGLState();
@@ -215,6 +221,7 @@ public:
     void ApplySamplers() const;
     void ApplyDepthClamp() const;
     void ApplyPolygonOffset() const;
+    void ApplyAlphaTest() const;
 
     /// Set the initial OpenGL state
     static void ApplyDefaultState();

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -128,6 +128,8 @@ inline GLenum PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
         return GL_TRIANGLE_STRIP;
     case Maxwell::PrimitiveTopology::TriangleFan:
         return GL_TRIANGLE_FAN;
+    case Maxwell::PrimitiveTopology::Quads:
+        return GL_QUADS;
     default:
         LOG_CRITICAL(Render_OpenGL, "Unimplemented topology={}", static_cast<u32>(topology));
         UNREACHABLE();
@@ -173,11 +175,8 @@ inline GLenum WrapMode(Tegra::Texture::WrapMode wrap_mode) {
         return GL_CLAMP_TO_EDGE;
     case Tegra::Texture::WrapMode::Border:
         return GL_CLAMP_TO_BORDER;
-    case Tegra::Texture::WrapMode::ClampOGL:
-        // TODO(Subv): GL_CLAMP was removed as of OpenGL 3.1, to implement GL_CLAMP, we can use
-        // GL_CLAMP_TO_BORDER to get the border color of the texture, and then sample the edge to
-        // manually mix them. However the shader part of this is not yet implemented.
-        return GL_CLAMP_TO_BORDER;
+    case Tegra::Texture::WrapMode::Clamp:
+        return GL_CLAMP;
     case Tegra::Texture::WrapMode::MirrorOnceClampToEdge:
         return GL_MIRROR_CLAMP_TO_EDGE;
     case Tegra::Texture::WrapMode::MirrorOnceBorder:

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -52,7 +52,7 @@ vk::SamplerAddressMode WrapMode(Tegra::Texture::WrapMode wrap_mode) {
         return vk::SamplerAddressMode::eClampToEdge;
     case Tegra::Texture::WrapMode::Border:
         return vk::SamplerAddressMode::eClampToBorder;
-    case Tegra::Texture::WrapMode::ClampOGL:
+    case Tegra::Texture::WrapMode::Clamp:
         // TODO(Rodrigo): GL_CLAMP was removed as of OpenGL 3.1, to implement GL_CLAMP, we can use
         // eClampToBorder to get the border color of the texture, and then sample the edge to
         // manually mix them. However the shader part of this is not yet implemented.

src/video_core/textures/texture.h

@@ -251,7 +251,7 @@ enum class WrapMode : u32 {
     Mirror = 1,
     ClampToEdge = 2,
     Border = 3,
-    ClampOGL = 4,
+    Clamp = 4,
     MirrorOnceClampToEdge = 5,
     MirrorOnceBorder = 6,
     MirrorOnceClampOGL = 7,

src/yuzu/applets/profile_select.cpp

@@ -27,20 +27,20 @@ constexpr std::array<u8, 107> backup_jpeg{
     0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
 };
 
-QString FormatUserEntryText(const QString& username, Common::UUID uuid) {
+QString FormatUserEntryText(const QString& username, Service::Account::UUID uuid) {
     return QtProfileSelectionDialog::tr(
                "%1\n%2", "%1 is the profile username, %2 is the formatted UUID (e.g. "
                          "00112233-4455-6677-8899-AABBCCDDEEFF))")
         .arg(username, QString::fromStdString(uuid.FormatSwitch()));
 }
 
-QString GetImagePath(Common::UUID uuid) {
+QString GetImagePath(Service::Account::UUID uuid) {
     const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
                       "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
     return QString::fromStdString(path);
 }
 
-QPixmap GetIcon(Common::UUID uuid) {
+QPixmap GetIcon(Service::Account::UUID uuid) {
     QPixmap icon{GetImagePath(uuid)};
 
     if (!icon) {
@@ -122,15 +122,21 @@ QtProfileSelectionDialog::QtProfileSelectionDialog(QWidget* parent)
 QtProfileSelectionDialog::~QtProfileSelectionDialog() = default;
 
 void QtProfileSelectionDialog::accept() {
+    ok = true;
     QDialog::accept();
 }
 
 void QtProfileSelectionDialog::reject() {
+    ok = false;
     user_index = 0;
     QDialog::reject();
 }
 
-int QtProfileSelectionDialog::GetIndex() const {
+bool QtProfileSelectionDialog::GetStatus() const {
+    return ok;
+}
+
+u32 QtProfileSelectionDialog::GetIndex() const {
     return user_index;
 }
 
@@ -148,12 +154,12 @@ QtProfileSelector::QtProfileSelector(GMainWindow& parent) {
 QtProfileSelector::~QtProfileSelector() = default;
 
 void QtProfileSelector::SelectProfile(
-    std::function<void(std::optional<Common::UUID>)> callback) const {
+    std::function<void(std::optional<Service::Account::UUID>)> callback) const {
     this->callback = std::move(callback);
     emit MainWindowSelectProfile();
 }
 
-void QtProfileSelector::MainWindowFinishedSelection(std::optional<Common::UUID> uuid) {
+void QtProfileSelector::MainWindowFinishedSelection(std::optional<Service::Account::UUID> uuid) {
     // Acquire the HLE mutex
     std::lock_guard lock{HLE::g_hle_lock};
     callback(uuid);

src/yuzu/applets/profile_select.h

@@ -9,7 +9,6 @@
 #include <QList>
 #include <QTreeView>
 #include "core/frontend/applets/profile_select.h"
-#include "core/hle/service/acc/profile_manager.h"
 
 class GMainWindow;
 class QDialogButtonBox;
@@ -30,12 +29,14 @@ public:
     void accept() override;
     void reject() override;
 
-    int GetIndex() const;
+    bool GetStatus() const;
+    u32 GetIndex() const;
 
 private:
-    void SelectUser(const QModelIndex& index);
+    bool ok = false;
+    u32 user_index = 0;
 
-    int user_index = 0;
+    void SelectUser(const QModelIndex& index);
 
     QVBoxLayout* layout;
     QTreeView* tree_view;
@@ -59,13 +60,14 @@ public:
     explicit QtProfileSelector(GMainWindow& parent);
     ~QtProfileSelector() override;
 
-    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
+    void SelectProfile(
+        std::function<void(std::optional<Service::Account::UUID>)> callback) const override;
 
 signals:
     void MainWindowSelectProfile() const;
 
 private:
-    void MainWindowFinishedSelection(std::optional<Common::UUID> uuid);
+    void MainWindowFinishedSelection(std::optional<Service::Account::UUID> uuid);
 
-    mutable std::function<void(std::optional<Common::UUID>)> callback;
+    mutable std::function<void(std::optional<Service::Account::UUID>)> callback;
 };

src/yuzu/applets/software_keyboard.cpp

@@ -104,11 +104,13 @@ QtSoftwareKeyboardDialog::QtSoftwareKeyboardDialog(
 QtSoftwareKeyboardDialog::~QtSoftwareKeyboardDialog() = default;
 
 void QtSoftwareKeyboardDialog::accept() {
+    ok = true;
     text = line_edit->text().toStdU16String();
     QDialog::accept();
 }
 
 void QtSoftwareKeyboardDialog::reject() {
+    ok = false;
     text.clear();
     QDialog::reject();
 }
@@ -117,6 +119,10 @@ std::u16string QtSoftwareKeyboardDialog::GetText() const {
     return text;
 }
 
+bool QtSoftwareKeyboardDialog::GetStatus() const {
+    return ok;
+}
+
 QtSoftwareKeyboard::QtSoftwareKeyboard(GMainWindow& main_window) {
     connect(this, &QtSoftwareKeyboard::MainWindowGetText, &main_window,
             &GMainWindow::SoftwareKeyboardGetText, Qt::QueuedConnection);

src/yuzu/applets/software_keyboard.h

@@ -36,8 +36,10 @@ public:
     void reject() override;
 
     std::u16string GetText() const;
+    bool GetStatus() const;
 
 private:
+    bool ok = false;
     std::u16string text;
 
     QDialogButtonBox* buttons;

src/yuzu/bootmanager.cpp

@@ -26,8 +26,6 @@
 
 EmuThread::EmuThread(GRenderWindow* render_window) : render_window(render_window) {}
 
-EmuThread::~EmuThread() = default;
-
 void EmuThread::run() {
     render_window->MakeCurrent();
 
@@ -187,7 +185,7 @@ private:
     bool do_painting;
 };
 
-GRenderWindow::GRenderWindow(GMainWindow* parent, EmuThread* emu_thread)
+GRenderWindow::GRenderWindow(QWidget* parent, EmuThread* emu_thread)
     : QWidget(parent), emu_thread(emu_thread) {
     setWindowTitle(QStringLiteral("yuzu %1 | %2-%3")
                        .arg(QString::fromUtf8(Common::g_build_name),
@@ -196,7 +194,8 @@ GRenderWindow::GRenderWindow(GMainWindow* parent, EmuThread* emu_thread)
     setAttribute(Qt::WA_AcceptTouchEvents);
 
     InputCommon::Init();
-    connect(this, &GRenderWindow::FirstFrameDisplayed, parent, &GMainWindow::OnLoadComplete);
+    connect(this, &GRenderWindow::FirstFrameDisplayed, static_cast<GMainWindow*>(parent),
+            &GMainWindow::OnLoadComplete);
 }
 
 GRenderWindow::~GRenderWindow() {
@@ -248,9 +247,9 @@ void GRenderWindow::PollEvents() {}
 void GRenderWindow::OnFramebufferSizeChanged() {
     // Screen changes potentially incur a change in screen DPI, hence we should update the
     // framebuffer size
-    const qreal pixel_ratio = GetWindowPixelRatio();
-    const u32 width = child->QPaintDevice::width() * pixel_ratio;
-    const u32 height = child->QPaintDevice::height() * pixel_ratio;
+    qreal pixelRatio = GetWindowPixelRatio();
+    unsigned width = child->QPaintDevice::width() * pixelRatio;
+    unsigned height = child->QPaintDevice::height() * pixelRatio;
     UpdateCurrentFramebufferLayout(width, height);
 }
 
@@ -267,7 +266,7 @@ void GRenderWindow::ForwardKeyReleaseEvent(QKeyEvent* event) {
 }
 
 void GRenderWindow::BackupGeometry() {
-    geometry = QWidget::saveGeometry();
+    geometry = ((QWidget*)this)->saveGeometry();
 }
 
 void GRenderWindow::RestoreGeometry() {
@@ -284,11 +283,10 @@ void GRenderWindow::restoreGeometry(const QByteArray& geometry) {
 QByteArray GRenderWindow::saveGeometry() {
     // If we are a top-level widget, store the current geometry
     // otherwise, store the last backup
-    if (parent() == nullptr) {
-        return QWidget::saveGeometry();
-    }
-
-    return geometry;
+    if (parent() == nullptr)
+        return ((QWidget*)this)->saveGeometry();
+    else
+        return geometry;
 }
 
 qreal GRenderWindow::GetWindowPixelRatio() const {
@@ -296,10 +294,10 @@ qreal GRenderWindow::GetWindowPixelRatio() const {
     return windowHandle() ? windowHandle()->screen()->devicePixelRatio() : 1.0f;
 }
 
-std::pair<u32, u32> GRenderWindow::ScaleTouch(const QPointF pos) const {
+std::pair<unsigned, unsigned> GRenderWindow::ScaleTouch(const QPointF pos) const {
     const qreal pixel_ratio = GetWindowPixelRatio();
-    return {static_cast<u32>(std::max(std::round(pos.x() * pixel_ratio), qreal{0.0})),
-            static_cast<u32>(std::max(std::round(pos.y() * pixel_ratio), qreal{0.0}))};
+    return {static_cast<unsigned>(std::max(std::round(pos.x() * pixel_ratio), qreal{0.0})),
+            static_cast<unsigned>(std::max(std::round(pos.y() * pixel_ratio), qreal{0.0}))};
 }
 
 void GRenderWindow::closeEvent(QCloseEvent* event) {
@@ -355,7 +353,7 @@ void GRenderWindow::focusOutEvent(QFocusEvent* event) {
     InputCommon::GetKeyboard()->ReleaseAllKeys();
 }
 
-void GRenderWindow::OnClientAreaResized(u32 width, u32 height) {
+void GRenderWindow::OnClientAreaResized(unsigned width, unsigned height) {
     NotifyClientAreaSizeChanged(std::make_pair(width, height));
 }
 
@@ -381,12 +379,8 @@ void GRenderWindow::InitRenderTarget() {
     // WA_DontShowOnScreen, WA_DeleteOnClose
     QSurfaceFormat fmt;
     fmt.setVersion(4, 3);
-    if (Settings::values.use_compatibility_profile) {
-        fmt.setProfile(QSurfaceFormat::CompatibilityProfile);
-        fmt.setOption(QSurfaceFormat::FormatOption::DeprecatedFunctions);
-    } else {
-        fmt.setProfile(QSurfaceFormat::CoreProfile);
-    }
+    fmt.setProfile(QSurfaceFormat::CompatibilityProfile);
+    fmt.setOption(QSurfaceFormat::FormatOption::DeprecatedFunctions);
     // TODO: expose a setting for buffer value (ie default/single/double/triple)
     fmt.setSwapBehavior(QSurfaceFormat::DefaultSwapBehavior);
     shared_context = std::make_unique<QOpenGLContext>();
@@ -396,7 +390,7 @@ void GRenderWindow::InitRenderTarget() {
     context->setShareContext(shared_context.get());
     context->setFormat(fmt);
     context->create();
-    fmt.setSwapInterval(0);
+    fmt.setSwapInterval(false);
 
     child = new GGLWidgetInternal(this, shared_context.get());
     container = QWidget::createWindowContainer(child, this);
@@ -426,29 +420,23 @@ void GRenderWindow::InitRenderTarget() {
     BackupGeometry();
 }
 
-void GRenderWindow::CaptureScreenshot(u32 res_scale, const QString& screenshot_path) {
+void GRenderWindow::CaptureScreenshot(u16 res_scale, const QString& screenshot_path) {
     auto& renderer = Core::System::GetInstance().Renderer();
 
-    if (res_scale == 0) {
+    if (!res_scale)
         res_scale = VideoCore::GetResolutionScaleFactor(renderer);
-    }
 
     const Layout::FramebufferLayout layout{Layout::FrameLayoutFromResolutionScale(res_scale)};
     screenshot_image = QImage(QSize(layout.width, layout.height), QImage::Format_RGB32);
-    renderer.RequestScreenshot(
-        screenshot_image.bits(),
-        [=] {
-            const std::string std_screenshot_path = screenshot_path.toStdString();
-            if (screenshot_image.mirrored(false, true).save(screenshot_path)) {
-                LOG_INFO(Frontend, "Screenshot saved to \"{}\"", std_screenshot_path);
-            } else {
-                LOG_ERROR(Frontend, "Failed to save screenshot to \"{}\"", std_screenshot_path);
-            }
-        },
-        layout);
+    renderer.RequestScreenshot(screenshot_image.bits(),
+                               [=] {
+                                   screenshot_image.mirrored(false, true).save(screenshot_path);
+                                   LOG_INFO(Frontend, "The screenshot is saved.");
+                               },
+                               layout);
 }
 
-void GRenderWindow::OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) {
+void GRenderWindow::OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned> minimal_size) {
     setMinimumSize(minimal_size.first, minimal_size.second);
 }
 

src/yuzu/bootmanager.h

@@ -27,12 +27,11 @@ namespace VideoCore {
 enum class LoadCallbackStage;
 }
 
-class EmuThread final : public QThread {
+class EmuThread : public QThread {
     Q_OBJECT
 
 public:
     explicit EmuThread(GRenderWindow* render_window);
-    ~EmuThread() override;
 
     /**
      * Start emulation (on new thread)
@@ -115,7 +114,7 @@ class GRenderWindow : public QWidget, public Core::Frontend::EmuWindow {
     Q_OBJECT
 
 public:
-    GRenderWindow(GMainWindow* parent, EmuThread* emu_thread);
+    GRenderWindow(QWidget* parent, EmuThread* emu_thread);
     ~GRenderWindow() override;
 
     // EmuWindow implementation
@@ -134,17 +133,17 @@ public:
     QByteArray saveGeometry();                        // overridden
 
     qreal GetWindowPixelRatio() const;
-    std::pair<u32, u32> ScaleTouch(QPointF pos) const;
+    std::pair<unsigned, unsigned> ScaleTouch(const QPointF pos) const;
 
     void closeEvent(QCloseEvent* event) override;
     bool event(QEvent* event) override;
     void focusOutEvent(QFocusEvent* event) override;
 
-    void OnClientAreaResized(u32 width, u32 height);
+    void OnClientAreaResized(unsigned width, unsigned height);
 
     void InitRenderTarget();
 
-    void CaptureScreenshot(u32 res_scale, const QString& screenshot_path);
+    void CaptureScreenshot(u16 res_scale, const QString& screenshot_path);
 
 public slots:
     void moveContext(); // overridden
@@ -163,7 +162,7 @@ private:
     void TouchUpdateEvent(const QTouchEvent* event);
     void TouchEndEvent();
 
-    void OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) override;
+    void OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned> minimal_size) override;
 
     QWidget* container = nullptr;
     GGLWidgetInternal* child = nullptr;

src/yuzu/configuration/config.cpp

@@ -531,8 +531,6 @@ void Config::ReadRendererValues() {
     Settings::values.use_frame_limit =
         ReadSetting(QStringLiteral("use_frame_limit"), true).toBool();
     Settings::values.frame_limit = ReadSetting(QStringLiteral("frame_limit"), 100).toInt();
-    Settings::values.use_compatibility_profile =
-        ReadSetting(QStringLiteral("use_compatibility_profile"), true).toBool();
     Settings::values.use_disk_shader_cache =
         ReadSetting(QStringLiteral("use_disk_shader_cache"), true).toBool();
     Settings::values.use_accurate_gpu_emulation =
@@ -645,8 +643,6 @@ void Config::ReadUIGamelistValues() {
     UISettings::values.icon_size = ReadSetting(QStringLiteral("icon_size"), 64).toUInt();
     UISettings::values.row_1_text_id = ReadSetting(QStringLiteral("row_1_text_id"), 3).toUInt();
     UISettings::values.row_2_text_id = ReadSetting(QStringLiteral("row_2_text_id"), 2).toUInt();
-    UISettings::values.cache_game_list =
-        ReadSetting(QStringLiteral("cache_game_list"), true).toBool();
 
     qt_config->endGroup();
 }
@@ -914,8 +910,6 @@ void Config::SaveRendererValues() {
                  static_cast<double>(Settings::values.resolution_factor), 1.0);
     WriteSetting(QStringLiteral("use_frame_limit"), Settings::values.use_frame_limit, true);
     WriteSetting(QStringLiteral("frame_limit"), Settings::values.frame_limit, 100);
-    WriteSetting(QStringLiteral("use_compatibility_profile"),
-                 Settings::values.use_compatibility_profile, true);
     WriteSetting(QStringLiteral("use_disk_shader_cache"), Settings::values.use_disk_shader_cache,
                  true);
     WriteSetting(QStringLiteral("use_accurate_gpu_emulation"),
@@ -1011,7 +1005,6 @@ void Config::SaveUIGamelistValues() {
     WriteSetting(QStringLiteral("icon_size"), UISettings::values.icon_size, 64);
     WriteSetting(QStringLiteral("row_1_text_id"), UISettings::values.row_1_text_id, 3);
     WriteSetting(QStringLiteral("row_2_text_id"), UISettings::values.row_2_text_id, 2);
-    WriteSetting(QStringLiteral("cache_game_list"), UISettings::values.cache_game_list, true);
 
     qt_config->endGroup();
 }

src/yuzu/configuration/configure_audio.cpp

@@ -4,8 +4,6 @@
 
 #include <memory>
 
-#include <QSignalBlocker>
-
 #include "audio_core/sink.h"
 #include "audio_core/sink_details.h"
 #include "core/core.h"
@@ -17,14 +15,18 @@ ConfigureAudio::ConfigureAudio(QWidget* parent)
     : QWidget(parent), ui(std::make_unique<Ui::ConfigureAudio>()) {
     ui->setupUi(this);
 
-    InitializeAudioOutputSinkComboBox();
+    ui->output_sink_combo_box->clear();
+    ui->output_sink_combo_box->addItem(QString::fromUtf8(AudioCore::auto_device_name));
+    for (const char* id : AudioCore::GetSinkIDs()) {
+        ui->output_sink_combo_box->addItem(QString::fromUtf8(id));
+    }
 
     connect(ui->volume_slider, &QSlider::valueChanged, this,
-            &ConfigureAudio::SetVolumeIndicatorText);
-    connect(ui->output_sink_combo_box, qOverload<int>(&QComboBox::currentIndexChanged), this,
-            &ConfigureAudio::UpdateAudioDevices);
+            &ConfigureAudio::setVolumeIndicatorText);
 
-    SetConfiguration();
+    this->setConfiguration();
+    connect(ui->output_sink_combo_box, qOverload<int>(&QComboBox::currentIndexChanged), this,
+            &ConfigureAudio::updateAudioDevices);
 
     const bool is_powered_on = Core::System::GetInstance().IsPoweredOn();
     ui->output_sink_combo_box->setEnabled(!is_powered_on);
@@ -33,23 +35,22 @@ ConfigureAudio::ConfigureAudio(QWidget* parent)
 
 ConfigureAudio::~ConfigureAudio() = default;
 
-void ConfigureAudio::SetConfiguration() {
-    SetOutputSinkFromSinkID();
+void ConfigureAudio::setConfiguration() {
+    setOutputSinkFromSinkID();
 
     // The device list cannot be pre-populated (nor listed) until the output sink is known.
-    UpdateAudioDevices(ui->output_sink_combo_box->currentIndex());
+    updateAudioDevices(ui->output_sink_combo_box->currentIndex());
 
-    SetAudioDeviceFromDeviceID();
+    setAudioDeviceFromDeviceID();
 
     ui->toggle_audio_stretching->setChecked(Settings::values.enable_audio_stretching);
     ui->volume_slider->setValue(Settings::values.volume * ui->volume_slider->maximum());
-    SetVolumeIndicatorText(ui->volume_slider->sliderPosition());
+    setVolumeIndicatorText(ui->volume_slider->sliderPosition());
 }
 
-void ConfigureAudio::SetOutputSinkFromSinkID() {
-    [[maybe_unused]] const QSignalBlocker blocker(ui->output_sink_combo_box);
-
+void ConfigureAudio::setOutputSinkFromSinkID() {
     int new_sink_index = 0;
+
     const QString sink_id = QString::fromStdString(Settings::values.sink_id);
     for (int index = 0; index < ui->output_sink_combo_box->count(); index++) {
         if (ui->output_sink_combo_box->itemText(index) == sink_id) {
@@ -61,7 +62,7 @@ void ConfigureAudio::SetOutputSinkFromSinkID() {
     ui->output_sink_combo_box->setCurrentIndex(new_sink_index);
 }
 
-void ConfigureAudio::SetAudioDeviceFromDeviceID() {
+void ConfigureAudio::setAudioDeviceFromDeviceID() {
     int new_device_index = -1;
 
     const QString device_id = QString::fromStdString(Settings::values.audio_device_id);
@@ -75,11 +76,11 @@ void ConfigureAudio::SetAudioDeviceFromDeviceID() {
     ui->audio_device_combo_box->setCurrentIndex(new_device_index);
 }
 
-void ConfigureAudio::SetVolumeIndicatorText(int percentage) {
+void ConfigureAudio::setVolumeIndicatorText(int percentage) {
     ui->volume_indicator->setText(tr("%1%", "Volume percentage (e.g. 50%)").arg(percentage));
 }
 
-void ConfigureAudio::ApplyConfiguration() {
+void ConfigureAudio::applyConfiguration() {
     Settings::values.sink_id =
         ui->output_sink_combo_box->itemText(ui->output_sink_combo_box->currentIndex())
             .toStdString();
@@ -91,15 +92,7 @@ void ConfigureAudio::ApplyConfiguration() {
         static_cast<float>(ui->volume_slider->sliderPosition()) / ui->volume_slider->maximum();
 }
 
-void ConfigureAudio::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QWidget::changeEvent(event);
-}
-
-void ConfigureAudio::UpdateAudioDevices(int sink_index) {
+void ConfigureAudio::updateAudioDevices(int sink_index) {
     ui->audio_device_combo_box->clear();
     ui->audio_device_combo_box->addItem(QString::fromUtf8(AudioCore::auto_device_name));
 
@@ -109,16 +102,6 @@ void ConfigureAudio::UpdateAudioDevices(int sink_index) {
     }
 }
 
-void ConfigureAudio::InitializeAudioOutputSinkComboBox() {
-    ui->output_sink_combo_box->clear();
-    ui->output_sink_combo_box->addItem(QString::fromUtf8(AudioCore::auto_device_name));
-
-    for (const char* id : AudioCore::GetSinkIDs()) {
-        ui->output_sink_combo_box->addItem(QString::fromUtf8(id));
-    }
-}
-
-void ConfigureAudio::RetranslateUI() {
+void ConfigureAudio::retranslateUi() {
     ui->retranslateUi(this);
-    SetVolumeIndicatorText(ui->volume_slider->sliderPosition());
 }

src/yuzu/configuration/configure_audio.h

@@ -18,21 +18,16 @@ public:
     explicit ConfigureAudio(QWidget* parent = nullptr);
     ~ConfigureAudio() override;
 
-    void ApplyConfiguration();
+    void applyConfiguration();
+    void retranslateUi();
 
 private:
-    void changeEvent(QEvent* event) override;
+    void updateAudioDevices(int sink_index);
 
-    void InitializeAudioOutputSinkComboBox();
-
-    void RetranslateUI();
-
-    void UpdateAudioDevices(int sink_index);
-
-    void SetConfiguration();
-    void SetOutputSinkFromSinkID();
-    void SetAudioDeviceFromDeviceID();
-    void SetVolumeIndicatorText(int percentage);
+    void setConfiguration();
+    void setOutputSinkFromSinkID();
+    void setAudioDeviceFromDeviceID();
+    void setVolumeIndicatorText(int percentage);
 
     std::unique_ptr<Ui::ConfigureAudio> ui;
 };

src/yuzu/configuration/configure_audio.ui

@@ -20,7 +20,7 @@
       <item>
        <layout class="QHBoxLayout">
         <item>
-         <widget class="QLabel" name="label_1">
+         <widget class="QLabel" name="label">
           <property name="text">
            <string>Output Engine:</string>
           </property>
@@ -44,7 +44,7 @@
       <item>
        <layout class="QHBoxLayout">
         <item>
-         <widget class="QLabel" name="label_2">
+         <widget class="QLabel" name="label">
           <property name="text">
            <string>Audio Device:</string>
           </property>
@@ -61,7 +61,7 @@
          <number>0</number>
         </property>
         <item>
-         <widget class="QLabel" name="label_3">
+         <widget class="QLabel" name="label">
           <property name="text">
            <string>Volume:</string>
           </property>

src/yuzu/configuration/configure_debug.cpp

@@ -16,8 +16,7 @@
 
 ConfigureDebug::ConfigureDebug(QWidget* parent) : QWidget(parent), ui(new Ui::ConfigureDebug) {
     ui->setupUi(this);
-    SetConfiguration();
-
+    this->setConfiguration();
     connect(ui->open_log_button, &QPushButton::pressed, []() {
         QString path = QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::LogDir));
         QDesktopServices::openUrl(QUrl::fromLocalFile(path));
@@ -26,7 +25,7 @@ ConfigureDebug::ConfigureDebug(QWidget* parent) : QWidget(parent), ui(new Ui::Co
 
 ConfigureDebug::~ConfigureDebug() = default;
 
-void ConfigureDebug::SetConfiguration() {
+void ConfigureDebug::setConfiguration() {
     ui->toggle_gdbstub->setChecked(Settings::values.use_gdbstub);
     ui->gdbport_spinbox->setEnabled(Settings::values.use_gdbstub);
     ui->gdbport_spinbox->setValue(Settings::values.gdbstub_port);
@@ -38,7 +37,7 @@ void ConfigureDebug::SetConfiguration() {
     ui->dump_decompressed_nso->setChecked(Settings::values.dump_nso);
 }
 
-void ConfigureDebug::ApplyConfiguration() {
+void ConfigureDebug::applyConfiguration() {
     Settings::values.use_gdbstub = ui->toggle_gdbstub->isChecked();
     Settings::values.gdbstub_port = ui->gdbport_spinbox->value();
     UISettings::values.show_console = ui->toggle_console->isChecked();
@@ -51,15 +50,3 @@ void ConfigureDebug::ApplyConfiguration() {
     filter.ParseFilterString(Settings::values.log_filter);
     Log::SetGlobalFilter(filter);
 }
-
-void ConfigureDebug::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QWidget::changeEvent(event);
-}
-
-void ConfigureDebug::RetranslateUI() {
-    ui->retranslateUi(this);
-}

src/yuzu/configuration/configure_debug.h

@@ -18,13 +18,10 @@ public:
     explicit ConfigureDebug(QWidget* parent = nullptr);
     ~ConfigureDebug() override;
 
-    void ApplyConfiguration();
+    void applyConfiguration();
 
 private:
-    void changeEvent(QEvent* event) override;
-
-    void RetranslateUI();
-    void SetConfiguration();
+    void setConfiguration();
 
     std::unique_ptr<Ui::ConfigureDebug> ui;
 };

src/yuzu/configuration/configure_debug.ui

@@ -45,7 +45,7 @@
            </spacer>
           </item>
           <item>
-           <widget class="QLabel" name="label_1">
+           <widget class="QLabel" name="label_2">
             <property name="text">
              <string>Port:</string>
             </property>
@@ -70,11 +70,11 @@
      <property name="title">
       <string>Logging</string>
      </property>
-     <layout class="QVBoxLayout" name="verticalLayout_4">
+     <layout class="QVBoxLayout" name="verticalLayout">
       <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_2">
+       <layout class="QHBoxLayout" name="horizontalLayout">
         <item>
-         <widget class="QLabel" name="label_2">
+         <widget class="QLabel" name="label">
           <property name="text">
            <string>Global Log Filter</string>
           </property>
@@ -86,7 +86,7 @@
        </layout>
       </item>
       <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_3">
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
         <item>
          <widget class="QCheckBox" name="toggle_console">
           <property name="text">
@@ -111,11 +111,11 @@
      <property name="title">
       <string>Homebrew</string>
      </property>
-     <layout class="QVBoxLayout" name="verticalLayout_5">
+     <layout class="QVBoxLayout" name="verticalLayout">
       <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_4">
+       <layout class="QHBoxLayout" name="horizontalLayout">
         <item>
-         <widget class="QLabel" name="label_3">
+         <widget class="QLabel" name="label">
           <property name="text">
            <string>Arguments String</string>
           </property>
@@ -134,7 +134,7 @@
      <property name="title">
       <string>Dump</string>
      </property>
-     <layout class="QVBoxLayout" name="verticalLayout_6">
+     <layout class="QVBoxLayout" name="verticalLayout_4">
       <item>
        <widget class="QCheckBox" name="dump_decompressed_nso">
         <property name="whatsThis">

src/yuzu/configuration/configure_dialog.cpp

@@ -4,7 +4,6 @@
 
 #include <QHash>
 #include <QListWidgetItem>
-#include <QSignalBlocker>
 #include "core/settings.h"
 #include "ui_configure.h"
 #include "yuzu/configuration/config.h"
@@ -16,10 +15,10 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry)
     : QDialog(parent), ui(new Ui::ConfigureDialog), registry(registry) {
     ui->setupUi(this);
     ui->hotkeysTab->Populate(registry);
-    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+    this->setConfiguration();
+    this->PopulateSelectionList();
 
-    SetConfiguration();
-    PopulateSelectionList();
+    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
     connect(ui->selectorList, &QListWidget::itemSelectionChanged, this,
             &ConfigureDialog::UpdateVisibleTabs);
@@ -30,55 +29,30 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry)
 
 ConfigureDialog::~ConfigureDialog() = default;
 
-void ConfigureDialog::SetConfiguration() {}
+void ConfigureDialog::setConfiguration() {}
 
-void ConfigureDialog::ApplyConfiguration() {
-    ui->generalTab->ApplyConfiguration();
-    ui->gameListTab->ApplyConfiguration();
-    ui->systemTab->ApplyConfiguration();
-    ui->profileManagerTab->ApplyConfiguration();
-    ui->inputTab->ApplyConfiguration();
-    ui->hotkeysTab->ApplyConfiguration(registry);
-    ui->graphicsTab->ApplyConfiguration();
-    ui->audioTab->ApplyConfiguration();
-    ui->debugTab->ApplyConfiguration();
-    ui->webTab->ApplyConfiguration();
+void ConfigureDialog::applyConfiguration() {
+    ui->generalTab->applyConfiguration();
+    ui->gameListTab->applyConfiguration();
+    ui->systemTab->applyConfiguration();
+    ui->profileManagerTab->applyConfiguration();
+    ui->inputTab->applyConfiguration();
+    ui->hotkeysTab->applyConfiguration(registry);
+    ui->graphicsTab->applyConfiguration();
+    ui->audioTab->applyConfiguration();
+    ui->debugTab->applyConfiguration();
+    ui->webTab->applyConfiguration();
     Settings::Apply();
     Settings::LogSettings();
 }
 
-void ConfigureDialog::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QDialog::changeEvent(event);
-}
-
-void ConfigureDialog::RetranslateUI() {
-    const int old_row = ui->selectorList->currentRow();
-    const int old_index = ui->tabWidget->currentIndex();
-
-    ui->retranslateUi(this);
-
-    PopulateSelectionList();
-    ui->selectorList->setCurrentRow(old_row);
-
-    UpdateVisibleTabs();
-    ui->tabWidget->setCurrentIndex(old_index);
-}
-
 void ConfigureDialog::PopulateSelectionList() {
     const std::array<std::pair<QString, QStringList>, 4> items{
         {{tr("General"), {tr("General"), tr("Web"), tr("Debug"), tr("Game List")}},
          {tr("System"), {tr("System"), tr("Profiles"), tr("Audio")}},
          {tr("Graphics"), {tr("Graphics")}},
-         {tr("Controls"), {tr("Input"), tr("Hotkeys")}}},
-    };
+         {tr("Controls"), {tr("Input"), tr("Hotkeys")}}}};
 
-    [[maybe_unused]] const QSignalBlocker blocker(ui->selectorList);
-
-    ui->selectorList->clear();
     for (const auto& entry : items) {
         auto* const item = new QListWidgetItem(entry.first);
         item->setData(Qt::UserRole, entry.second);
@@ -89,28 +63,24 @@ void ConfigureDialog::PopulateSelectionList() {
 
 void ConfigureDialog::UpdateVisibleTabs() {
     const auto items = ui->selectorList->selectedItems();
-    if (items.isEmpty()) {
+    if (items.isEmpty())
         return;
-    }
 
-    const std::map<QString, QWidget*> widgets = {
-        {tr("General"), ui->generalTab},
-        {tr("System"), ui->systemTab},
-        {tr("Profiles"), ui->profileManagerTab},
-        {tr("Input"), ui->inputTab},
-        {tr("Hotkeys"), ui->hotkeysTab},
-        {tr("Graphics"), ui->graphicsTab},
-        {tr("Audio"), ui->audioTab},
-        {tr("Debug"), ui->debugTab},
-        {tr("Web"), ui->webTab},
-        {tr("Game List"), ui->gameListTab},
-    };
-
-    [[maybe_unused]] const QSignalBlocker blocker(ui->tabWidget);
+    const std::map<QString, QWidget*> widgets = {{tr("General"), ui->generalTab},
+                                                 {tr("System"), ui->systemTab},
+                                                 {tr("Profiles"), ui->profileManagerTab},
+                                                 {tr("Input"), ui->inputTab},
+                                                 {tr("Hotkeys"), ui->hotkeysTab},
+                                                 {tr("Graphics"), ui->graphicsTab},
+                                                 {tr("Audio"), ui->audioTab},
+                                                 {tr("Debug"), ui->debugTab},
+                                                 {tr("Web"), ui->webTab},
+                                                 {tr("Game List"), ui->gameListTab}};
 
     ui->tabWidget->clear();
+
     const QStringList tabs = items[0]->data(Qt::UserRole).toStringList();
-    for (const auto& tab : tabs) {
+
+    for (const auto& tab : tabs)
         ui->tabWidget->addTab(widgets.find(tab)->second, tab);
-    }
 }

src/yuzu/configuration/configure_dialog.h

@@ -20,14 +20,10 @@ public:
     explicit ConfigureDialog(QWidget* parent, HotkeyRegistry& registry);
     ~ConfigureDialog() override;
 
-    void ApplyConfiguration();
+    void applyConfiguration();
 
 private:
-    void changeEvent(QEvent* event) override;
-
-    void RetranslateUI();
-
-    void SetConfiguration();
+    void setConfiguration();
     void UpdateVisibleTabs();
     void PopulateSelectionList();
 

src/yuzu/configuration/configure_gamelist.cpp

@@ -12,20 +12,20 @@
 #include "yuzu/ui_settings.h"
 
 namespace {
-constexpr std::array default_icon_sizes{
+constexpr std::array<std::pair<u32, const char*>, 5> default_icon_sizes{{
     std::make_pair(0, QT_TR_NOOP("None")),
     std::make_pair(32, QT_TR_NOOP("Small (32x32)")),
     std::make_pair(64, QT_TR_NOOP("Standard (64x64)")),
     std::make_pair(128, QT_TR_NOOP("Large (128x128)")),
     std::make_pair(256, QT_TR_NOOP("Full Size (256x256)")),
-};
+}};
 
-constexpr std::array row_text_names{
+constexpr std::array<const char*, 4> row_text_names{{
     QT_TR_NOOP("Filename"),
     QT_TR_NOOP("Filetype"),
     QT_TR_NOOP("Title ID"),
     QT_TR_NOOP("Title Name"),
-};
+}};
 } // Anonymous namespace
 
 ConfigureGameList::ConfigureGameList(QWidget* parent)
@@ -35,7 +35,7 @@ ConfigureGameList::ConfigureGameList(QWidget* parent)
     InitializeIconSizeComboBox();
     InitializeRowComboBoxes();
 
-    SetConfiguration();
+    this->setConfiguration();
 
     // Force game list reload if any of the relevant settings are changed.
     connect(ui->show_unknown, &QCheckBox::stateChanged, this,
@@ -50,7 +50,7 @@ ConfigureGameList::ConfigureGameList(QWidget* parent)
 
 ConfigureGameList::~ConfigureGameList() = default;
 
-void ConfigureGameList::ApplyConfiguration() {
+void ConfigureGameList::applyConfiguration() {
     UISettings::values.show_unknown = ui->show_unknown->isChecked();
     UISettings::values.show_add_ons = ui->show_add_ons->isChecked();
     UISettings::values.icon_size = ui->icon_size_combobox->currentData().toUInt();
@@ -63,7 +63,7 @@ void ConfigureGameList::RequestGameListUpdate() {
     UISettings::values.is_game_list_reload_pending.exchange(true);
 }
 
-void ConfigureGameList::SetConfiguration() {
+void ConfigureGameList::setConfiguration() {
     ui->show_unknown->setChecked(UISettings::values.show_unknown);
     ui->show_add_ons->setChecked(UISettings::values.show_add_ons);
     ui->icon_size_combobox->setCurrentIndex(
@@ -77,6 +77,7 @@ void ConfigureGameList::SetConfiguration() {
 void ConfigureGameList::changeEvent(QEvent* event) {
     if (event->type() == QEvent::LanguageChange) {
         RetranslateUI();
+        return;
     }
 
     QWidget::changeEvent(event);

src/yuzu/configuration/configure_gamelist.h

@@ -18,12 +18,12 @@ public:
     explicit ConfigureGameList(QWidget* parent = nullptr);
     ~ConfigureGameList() override;
 
-    void ApplyConfiguration();
+    void applyConfiguration();
 
 private:
     void RequestGameListUpdate();
 
-    void SetConfiguration();
+    void setConfiguration();
 
     void changeEvent(QEvent*) override;
     void RetranslateUI();

src/yuzu/configuration/configure_general.cpp

@@ -18,7 +18,7 @@ ConfigureGeneral::ConfigureGeneral(QWidget* parent)
                                     QString::fromUtf8(theme.second));
     }
 
-    SetConfiguration();
+    this->setConfiguration();
 
     connect(ui->toggle_deepscan, &QCheckBox::stateChanged, this,
             [] { UISettings::values.is_game_list_reload_pending.exchange(true); });
@@ -28,7 +28,7 @@ ConfigureGeneral::ConfigureGeneral(QWidget* parent)
 
 ConfigureGeneral::~ConfigureGeneral() = default;
 
-void ConfigureGeneral::SetConfiguration() {
+void ConfigureGeneral::setConfiguration() {
     ui->toggle_deepscan->setChecked(UISettings::values.game_directory_deepscan);
     ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing);
     ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot);
@@ -36,7 +36,7 @@ void ConfigureGeneral::SetConfiguration() {
     ui->use_cpu_jit->setChecked(Settings::values.use_cpu_jit);
 }
 
-void ConfigureGeneral::ApplyConfiguration() {
+void ConfigureGeneral::applyConfiguration() {
     UISettings::values.game_directory_deepscan = ui->toggle_deepscan->isChecked();
     UISettings::values.confirm_before_closing = ui->toggle_check_exit->isChecked();
     UISettings::values.select_user_on_boot = ui->toggle_user_on_boot->isChecked();
@@ -45,15 +45,3 @@ void ConfigureGeneral::ApplyConfiguration() {
 
     Settings::values.use_cpu_jit = ui->use_cpu_jit->isChecked();
 }
-
-void ConfigureGeneral::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QWidget::changeEvent(event);
-}
-
-void ConfigureGeneral::RetranslateUI() {
-    ui->retranslateUi(this);
-}

src/yuzu/configuration/configure_general.h

@@ -20,13 +20,10 @@ public:
     explicit ConfigureGeneral(QWidget* parent = nullptr);
     ~ConfigureGeneral() override;
 
-    void ApplyConfiguration();
+    void applyConfiguration();
 
 private:
-    void changeEvent(QEvent* event) override;
-    void RetranslateUI();
-
-    void SetConfiguration();
+    void setConfiguration();
 
     std::unique_ptr<Ui::ConfigureGeneral> ui;
 };

src/yuzu/configuration/configure_graphics.cpp

@@ -51,32 +51,30 @@ Resolution FromResolutionFactor(float factor) {
 
 ConfigureGraphics::ConfigureGraphics(QWidget* parent)
     : QWidget(parent), ui(new Ui::ConfigureGraphics) {
+
     ui->setupUi(this);
+    this->setConfiguration();
 
-    SetConfiguration();
-
-    connect(ui->toggle_frame_limit, &QCheckBox::toggled, ui->frame_limit, &QSpinBox::setEnabled);
+    ui->frame_limit->setEnabled(Settings::values.use_frame_limit);
+    connect(ui->toggle_frame_limit, &QCheckBox::stateChanged, ui->frame_limit,
+            &QSpinBox::setEnabled);
     connect(ui->bg_button, &QPushButton::clicked, this, [this] {
         const QColor new_bg_color = QColorDialog::getColor(bg_color);
-        if (!new_bg_color.isValid()) {
+        if (!new_bg_color.isValid())
             return;
-        }
         UpdateBackgroundColorButton(new_bg_color);
     });
 }
 
 ConfigureGraphics::~ConfigureGraphics() = default;
 
-void ConfigureGraphics::SetConfiguration() {
+void ConfigureGraphics::setConfiguration() {
     const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
 
     ui->resolution_factor_combobox->setCurrentIndex(
         static_cast<int>(FromResolutionFactor(Settings::values.resolution_factor)));
     ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit);
-    ui->frame_limit->setEnabled(ui->toggle_frame_limit->isChecked());
     ui->frame_limit->setValue(Settings::values.frame_limit);
-    ui->use_compatibility_profile->setEnabled(runtime_lock);
-    ui->use_compatibility_profile->setChecked(Settings::values.use_compatibility_profile);
     ui->use_disk_shader_cache->setEnabled(runtime_lock);
     ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache);
     ui->use_accurate_gpu_emulation->setChecked(Settings::values.use_accurate_gpu_emulation);
@@ -88,12 +86,11 @@ void ConfigureGraphics::SetConfiguration() {
                                                  Settings::values.bg_blue));
 }
 
-void ConfigureGraphics::ApplyConfiguration() {
+void ConfigureGraphics::applyConfiguration() {
     Settings::values.resolution_factor =
         ToResolutionFactor(static_cast<Resolution>(ui->resolution_factor_combobox->currentIndex()));
     Settings::values.use_frame_limit = ui->toggle_frame_limit->isChecked();
     Settings::values.frame_limit = ui->frame_limit->value();
-    Settings::values.use_compatibility_profile = ui->use_compatibility_profile->isChecked();
     Settings::values.use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
     Settings::values.use_accurate_gpu_emulation = ui->use_accurate_gpu_emulation->isChecked();
     Settings::values.use_asynchronous_gpu_emulation =
@@ -104,18 +101,6 @@ void ConfigureGraphics::ApplyConfiguration() {
     Settings::values.bg_blue = static_cast<float>(bg_color.blueF());
 }
 
-void ConfigureGraphics::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QWidget::changeEvent(event);
-}
-
-void ConfigureGraphics::RetranslateUI() {
-    ui->retranslateUi(this);
-}
-
 void ConfigureGraphics::UpdateBackgroundColorButton(QColor color) {
     bg_color = color;
 

src/yuzu/configuration/configure_graphics.h

@@ -18,13 +18,10 @@ public:
     explicit ConfigureGraphics(QWidget* parent = nullptr);
     ~ConfigureGraphics() override;
 
-    void ApplyConfiguration();
+    void applyConfiguration();
 
 private:
-    void changeEvent(QEvent* event) override;
-    void RetranslateUI();
-
-    void SetConfiguration();
+    void setConfiguration();
 
     void UpdateBackgroundColorButton(QColor color);
 

src/yuzu/configuration/configure_graphics.ui

@@ -49,13 +49,6 @@
           </item>
          </layout>
         </item>
-        <item>
-         <widget class="QCheckBox" name="use_compatibility_profile">
-          <property name="text">
-           <string>Use OpenGL compatibility profile</string>
-          </property>
-         </widget>
-        </item>
         <item>
          <widget class="QCheckBox" name="use_disk_shader_cache">
           <property name="text">

src/yuzu/configuration/configure_hotkeys.cpp

@@ -17,6 +17,7 @@ ConfigureHotkeys::ConfigureHotkeys(QWidget* parent)
 
     model = new QStandardItemModel(this);
     model->setColumnCount(3);
+    model->setHorizontalHeaderLabels({tr("Action"), tr("Hotkey"), tr("Context")});
 
     connect(ui->hotkey_list, &QTreeView::doubleClicked, this, &ConfigureHotkeys::Configure);
     ui->hotkey_list->setModel(model);
@@ -26,8 +27,6 @@ ConfigureHotkeys::ConfigureHotkeys(QWidget* parent)
 
     ui->hotkey_list->setColumnWidth(0, 200);
     ui->hotkey_list->resizeColumnToContents(1);
-
-    RetranslateUI();
 }
 
 ConfigureHotkeys::~ConfigureHotkeys() = default;
@@ -50,20 +49,6 @@ void ConfigureHotkeys::Populate(const HotkeyRegistry& registry) {
     ui->hotkey_list->expandAll();
 }
 
-void ConfigureHotkeys::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QWidget::changeEvent(event);
-}
-
-void ConfigureHotkeys::RetranslateUI() {
-    ui->retranslateUi(this);
-
-    model->setHorizontalHeaderLabels({tr("Action"), tr("Hotkey"), tr("Context")});
-}
-
 void ConfigureHotkeys::Configure(QModelIndex index) {
     if (!index.parent().isValid()) {
         return;
@@ -107,7 +92,7 @@ bool ConfigureHotkeys::IsUsedKey(QKeySequence key_sequence) const {
     return false;
 }
 
-void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
+void ConfigureHotkeys::applyConfiguration(HotkeyRegistry& registry) {
     for (int key_id = 0; key_id < model->rowCount(); key_id++) {
         const QStandardItem* parent = model->item(key_id, 0);
         for (int key_column_id = 0; key_column_id < parent->rowCount(); key_column_id++) {
@@ -127,3 +112,7 @@ void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
 
     registry.SaveHotkeys();
 }
+
+void ConfigureHotkeys::retranslateUi() {
+    ui->retranslateUi(this);
+}

src/yuzu/configuration/configure_hotkeys.h

@@ -21,7 +21,8 @@ public:
     explicit ConfigureHotkeys(QWidget* parent = nullptr);
     ~ConfigureHotkeys() override;
 
-    void ApplyConfiguration(HotkeyRegistry& registry);
+    void applyConfiguration(HotkeyRegistry& registry);
+    void retranslateUi();
 
     /**
      * Populates the hotkey list widget using data from the provided registry.
@@ -31,9 +32,6 @@ public:
     void Populate(const HotkeyRegistry& registry);
 
 private:
-    void changeEvent(QEvent* event) override;
-    void RetranslateUI();
-
     void Configure(QModelIndex index);
     bool IsUsedKey(QKeySequence key_sequence) const;
 

src/yuzu/configuration/configure_input.cpp

@@ -5,7 +5,6 @@
 #include <algorithm>
 #include <memory>
 
-#include <QSignalBlocker>
 #include <QTimer>
 
 #include "configuration/configure_touchscreen_advanced.h"
@@ -51,12 +50,12 @@ void OnDockedModeChanged(bool last_state, bool new_state) {
 namespace {
 template <typename Dialog, typename... Args>
 void CallConfigureDialog(ConfigureInput& parent, Args&&... args) {
-    parent.ApplyConfiguration();
+    parent.applyConfiguration();
     Dialog dialog(&parent, std::forward<Args>(args)...);
 
     const auto res = dialog.exec();
     if (res == QDialog::Accepted) {
-        dialog.ApplyConfiguration();
+        dialog.applyConfiguration();
     }
 }
 } // Anonymous namespace
@@ -75,25 +74,29 @@ ConfigureInput::ConfigureInput(QWidget* parent)
         ui->player5_configure, ui->player6_configure, ui->player7_configure, ui->player8_configure,
     };
 
-    RetranslateUI();
-    LoadConfiguration();
-    UpdateUIEnabled();
+    for (auto* controller_box : players_controller) {
+        controller_box->addItems({tr("None"), tr("Pro Controller"), tr("Dual Joycons"),
+                                  tr("Single Right Joycon"), tr("Single Left Joycon")});
+    }
+
+    this->loadConfiguration();
+    updateUIEnabled();
 
     connect(ui->restore_defaults_button, &QPushButton::pressed, this,
-            &ConfigureInput::RestoreDefaults);
+            &ConfigureInput::restoreDefaults);
 
     for (auto* enabled : players_controller) {
         connect(enabled, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
-                &ConfigureInput::UpdateUIEnabled);
+                &ConfigureInput::updateUIEnabled);
     }
-    connect(ui->use_docked_mode, &QCheckBox::stateChanged, this, &ConfigureInput::UpdateUIEnabled);
+    connect(ui->use_docked_mode, &QCheckBox::stateChanged, this, &ConfigureInput::updateUIEnabled);
     connect(ui->handheld_connected, &QCheckBox::stateChanged, this,
-            &ConfigureInput::UpdateUIEnabled);
-    connect(ui->mouse_enabled, &QCheckBox::stateChanged, this, &ConfigureInput::UpdateUIEnabled);
-    connect(ui->keyboard_enabled, &QCheckBox::stateChanged, this, &ConfigureInput::UpdateUIEnabled);
-    connect(ui->debug_enabled, &QCheckBox::stateChanged, this, &ConfigureInput::UpdateUIEnabled);
+            &ConfigureInput::updateUIEnabled);
+    connect(ui->mouse_enabled, &QCheckBox::stateChanged, this, &ConfigureInput::updateUIEnabled);
+    connect(ui->keyboard_enabled, &QCheckBox::stateChanged, this, &ConfigureInput::updateUIEnabled);
+    connect(ui->debug_enabled, &QCheckBox::stateChanged, this, &ConfigureInput::updateUIEnabled);
     connect(ui->touchscreen_enabled, &QCheckBox::stateChanged, this,
-            &ConfigureInput::UpdateUIEnabled);
+            &ConfigureInput::updateUIEnabled);
 
     for (std::size_t i = 0; i < players_configure.size(); ++i) {
         connect(players_configure[i], &QPushButton::pressed, this,
@@ -115,7 +118,7 @@ ConfigureInput::ConfigureInput(QWidget* parent)
 
 ConfigureInput::~ConfigureInput() = default;
 
-void ConfigureInput::ApplyConfiguration() {
+void ConfigureInput::applyConfiguration() {
     for (std::size_t i = 0; i < players_controller.size(); ++i) {
         const auto controller_type_index = players_controller[i]->currentIndex();
 
@@ -141,32 +144,7 @@ void ConfigureInput::ApplyConfiguration() {
     Settings::values.touchscreen.enabled = ui->touchscreen_enabled->isChecked();
 }
 
-void ConfigureInput::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QDialog::changeEvent(event);
-}
-
-void ConfigureInput::RetranslateUI() {
-    ui->retranslateUi(this);
-    RetranslateControllerComboBoxes();
-}
-
-void ConfigureInput::RetranslateControllerComboBoxes() {
-    for (auto* controller_box : players_controller) {
-        [[maybe_unused]] const QSignalBlocker blocker(controller_box);
-
-        controller_box->clear();
-        controller_box->addItems({tr("None"), tr("Pro Controller"), tr("Dual Joycons"),
-                                  tr("Single Right Joycon"), tr("Single Left Joycon")});
-    }
-
-    LoadPlayerControllerIndices();
-}
-
-void ConfigureInput::UpdateUIEnabled() {
+void ConfigureInput::updateUIEnabled() {
     bool hit_disabled = false;
     for (auto* player : players_controller) {
         player->setDisabled(hit_disabled);
@@ -190,14 +168,18 @@ void ConfigureInput::UpdateUIEnabled() {
     ui->touchscreen_advanced->setEnabled(ui->touchscreen_enabled->isChecked());
 }
 
-void ConfigureInput::LoadConfiguration() {
+void ConfigureInput::loadConfiguration() {
     std::stable_partition(
         Settings::values.players.begin(),
         Settings::values.players.begin() +
             Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD),
         [](const auto& player) { return player.connected; });
 
-    LoadPlayerControllerIndices();
+    for (std::size_t i = 0; i < players_controller.size(); ++i) {
+        const auto connected = Settings::values.players[i].connected;
+        players_controller[i]->setCurrentIndex(
+            connected ? static_cast<u8>(Settings::values.players[i].type) + 1 : 0);
+    }
 
     ui->use_docked_mode->setChecked(Settings::values.use_docked_mode);
     ui->handheld_connected->setChecked(
@@ -209,18 +191,10 @@ void ConfigureInput::LoadConfiguration() {
     ui->keyboard_enabled->setChecked(Settings::values.keyboard_enabled);
     ui->touchscreen_enabled->setChecked(Settings::values.touchscreen.enabled);
 
-    UpdateUIEnabled();
+    updateUIEnabled();
 }
 
-void ConfigureInput::LoadPlayerControllerIndices() {
-    for (std::size_t i = 0; i < players_controller.size(); ++i) {
-        const auto connected = Settings::values.players[i].connected;
-        players_controller[i]->setCurrentIndex(
-            connected ? static_cast<u8>(Settings::values.players[i].type) + 1 : 0);
-    }
-}
-
-void ConfigureInput::RestoreDefaults() {
+void ConfigureInput::restoreDefaults() {
     players_controller[0]->setCurrentIndex(2);
 
     for (std::size_t i = 1; i < players_controller.size(); ++i) {
@@ -233,5 +207,5 @@ void ConfigureInput::RestoreDefaults() {
     ui->keyboard_enabled->setCheckState(Qt::Unchecked);
     ui->debug_enabled->setCheckState(Qt::Unchecked);
     ui->touchscreen_enabled->setCheckState(Qt::Checked);
-    UpdateUIEnabled();
+    updateUIEnabled();
 }

src/yuzu/configuration/configure_input.h

@@ -30,21 +30,15 @@ public:
     ~ConfigureInput() override;
 
     /// Save all button configurations to settings file
-    void ApplyConfiguration();
+    void applyConfiguration();
 
 private:
-    void changeEvent(QEvent* event) override;
-    void RetranslateUI();
-    void RetranslateControllerComboBoxes();
-
-    void UpdateUIEnabled();
+    void updateUIEnabled();
 
     /// Load configuration settings.
-    void LoadConfiguration();
-    void LoadPlayerControllerIndices();
-
+    void loadConfiguration();
     /// Restore all buttons to their default values.
-    void RestoreDefaults();
+    void restoreDefaults();
 
     std::unique_ptr<Ui::ConfigureInput> ui;
 

src/yuzu/configuration/configure_input.ui

@@ -17,7 +17,7 @@
    <item>
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
-      <widget class="QGroupBox" name="gridGroupBox_1">
+      <widget class="QGroupBox" name="gridGroupBox">
        <property name="title">
         <string>Players</string>
        </property>
@@ -260,7 +260,7 @@
       </widget>
      </item>
      <item>
-      <widget class="QGroupBox" name="gridGroupBox_2">
+      <widget class="QGroupBox" name="gridGroupBox">
        <property name="title">
         <string>Handheld</string>
        </property>
@@ -332,7 +332,7 @@
       </widget>
      </item>
      <item>
-      <widget class="QGroupBox" name="gridGroupBox_3">
+      <widget class="QGroupBox" name="gridGroupBox">
        <property name="title">
         <string>Other</string>
        </property>

src/yuzu/configuration/configure_input_player.cpp

@@ -245,7 +245,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
 
         button->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(button, &QPushButton::released, [=] {
-            HandleClick(
+            handleClick(
                 button_map[button_id],
                 [=](const Common::ParamPackage& params) { buttons_param[button_id] = params; },
                 InputCommon::Polling::DeviceType::Button);
@@ -274,7 +274,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
 
             analog_button->setContextMenuPolicy(Qt::CustomContextMenu);
             connect(analog_button, &QPushButton::released, [=]() {
-                HandleClick(analog_map_buttons[analog_id][sub_button_id],
+                handleClick(analog_map_buttons[analog_id][sub_button_id],
                             [=](const Common::ParamPackage& params) {
                                 SetAnalogButton(params, analogs_param[analog_id],
                                                 analog_sub_buttons[sub_button_id]);
@@ -304,7 +304,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
             QMessageBox::information(this, tr("Information"),
                                      tr("After pressing OK, first move your joystick horizontally, "
                                         "and then vertically."));
-            HandleClick(
+            handleClick(
                 analog_map_stick[analog_id],
                 [=](const Common::ParamPackage& params) { analogs_param[analog_id] = params; },
                 InputCommon::Polling::DeviceType::Analog);
@@ -312,17 +312,17 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
     }
 
     connect(ui->buttonClearAll, &QPushButton::released, [this] { ClearAll(); });
-    connect(ui->buttonRestoreDefaults, &QPushButton::released, [this] { RestoreDefaults(); });
+    connect(ui->buttonRestoreDefaults, &QPushButton::released, [this]() { restoreDefaults(); });
 
     timeout_timer->setSingleShot(true);
-    connect(timeout_timer.get(), &QTimer::timeout, [this] { SetPollingResult({}, true); });
+    connect(timeout_timer.get(), &QTimer::timeout, [this]() { setPollingResult({}, true); });
 
-    connect(poll_timer.get(), &QTimer::timeout, [this] {
+    connect(poll_timer.get(), &QTimer::timeout, [this]() {
         Common::ParamPackage params;
         for (auto& poller : device_pollers) {
             params = poller->GetNextInput();
             if (params.Has("engine")) {
-                SetPollingResult(params, false);
+                setPollingResult(params, false);
                 return;
             }
         }
@@ -340,8 +340,8 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
                 [this, i] { OnControllerButtonClick(static_cast<int>(i)); });
     }
 
-    LoadConfiguration();
-    resize(0, 0);
+    this->loadConfiguration();
+    this->resize(0, 0);
 
     // TODO(wwylele): enable this when we actually emulate it
     ui->buttonHome->setEnabled(false);
@@ -349,7 +349,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
 
 ConfigureInputPlayer::~ConfigureInputPlayer() = default;
 
-void ConfigureInputPlayer::ApplyConfiguration() {
+void ConfigureInputPlayer::applyConfiguration() {
     auto& buttons =
         debug ? Settings::values.debug_pad_buttons : Settings::values.players[player_index].buttons;
     auto& analogs =
@@ -373,19 +373,6 @@ void ConfigureInputPlayer::ApplyConfiguration() {
     Settings::values.players[player_index].button_color_right = colors[3];
 }
 
-void ConfigureInputPlayer::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QDialog::changeEvent(event);
-}
-
-void ConfigureInputPlayer::RetranslateUI() {
-    ui->retranslateUi(this);
-    UpdateButtonLabels();
-}
-
 void ConfigureInputPlayer::OnControllerButtonClick(int i) {
     const QColor new_bg_color = QColorDialog::getColor(controller_colors[i]);
     if (!new_bg_color.isValid())
@@ -395,7 +382,7 @@ void ConfigureInputPlayer::OnControllerButtonClick(int i) {
         QStringLiteral("QPushButton { background-color: %1 }").arg(controller_colors[i].name()));
 }
 
-void ConfigureInputPlayer::LoadConfiguration() {
+void ConfigureInputPlayer::loadConfiguration() {
     if (debug) {
         std::transform(Settings::values.debug_pad_buttons.begin(),
                        Settings::values.debug_pad_buttons.end(), buttons_param.begin(),
@@ -412,7 +399,7 @@ void ConfigureInputPlayer::LoadConfiguration() {
                        [](const std::string& str) { return Common::ParamPackage(str); });
     }
 
-    UpdateButtonLabels();
+    updateButtonLabels();
 
     if (debug)
         return;
@@ -434,7 +421,7 @@ void ConfigureInputPlayer::LoadConfiguration() {
     }
 }
 
-void ConfigureInputPlayer::RestoreDefaults() {
+void ConfigureInputPlayer::restoreDefaults() {
     for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; button_id++) {
         buttons_param[button_id] = Common::ParamPackage{
             InputCommon::GenerateKeyboardParam(Config::default_buttons[button_id])};
@@ -447,7 +434,7 @@ void ConfigureInputPlayer::RestoreDefaults() {
             SetAnalogButton(params, analogs_param[analog_id], analog_sub_buttons[sub_button_id]);
         }
     }
-    UpdateButtonLabels();
+    updateButtonLabels();
 }
 
 void ConfigureInputPlayer::ClearAll() {
@@ -471,10 +458,10 @@ void ConfigureInputPlayer::ClearAll() {
         }
     }
 
-    UpdateButtonLabels();
+    updateButtonLabels();
 }
 
-void ConfigureInputPlayer::UpdateButtonLabels() {
+void ConfigureInputPlayer::updateButtonLabels() {
     for (int button = 0; button < Settings::NativeButton::NumButtons; button++) {
         button_map[button]->setText(ButtonToText(buttons_param[button]));
     }
@@ -494,7 +481,7 @@ void ConfigureInputPlayer::UpdateButtonLabels() {
     }
 }
 
-void ConfigureInputPlayer::HandleClick(
+void ConfigureInputPlayer::handleClick(
     QPushButton* button, std::function<void(const Common::ParamPackage&)> new_input_setter,
     InputCommon::Polling::DeviceType type) {
     button->setText(tr("[press key]"));
@@ -522,7 +509,7 @@ void ConfigureInputPlayer::HandleClick(
     poll_timer->start(200);     // Check for new inputs every 200ms
 }
 
-void ConfigureInputPlayer::SetPollingResult(const Common::ParamPackage& params, bool abort) {
+void ConfigureInputPlayer::setPollingResult(const Common::ParamPackage& params, bool abort) {
     releaseKeyboard();
     releaseMouse();
     timeout_timer->stop();
@@ -535,23 +522,22 @@ void ConfigureInputPlayer::SetPollingResult(const Common::ParamPackage& params,
         (*input_setter)(params);
     }
 
-    UpdateButtonLabels();
+    updateButtonLabels();
     input_setter = std::nullopt;
 }
 
 void ConfigureInputPlayer::keyPressEvent(QKeyEvent* event) {
-    if (!input_setter || !event) {
+    if (!input_setter || !event)
         return;
-    }
 
     if (event->key() != Qt::Key_Escape) {
         if (want_keyboard_keys) {
-            SetPollingResult(Common::ParamPackage{InputCommon::GenerateKeyboardParam(event->key())},
+            setPollingResult(Common::ParamPackage{InputCommon::GenerateKeyboardParam(event->key())},
                              false);
         } else {
             // Escape key wasn't pressed and we don't want any keyboard keys, so don't stop polling
             return;
         }
     }
-    SetPollingResult({}, true);
+    setPollingResult({}, true);
 }

src/yuzu/configuration/configure_input_player.h

@@ -38,31 +38,28 @@ public:
     ~ConfigureInputPlayer() override;
 
     /// Save all button configurations to settings file
-    void ApplyConfiguration();
+    void applyConfiguration();
 
 private:
-    void changeEvent(QEvent* event) override;
-    void RetranslateUI();
-
     void OnControllerButtonClick(int i);
 
     /// Load configuration settings.
-    void LoadConfiguration();
+    void loadConfiguration();
     /// Restore all buttons to their default values.
-    void RestoreDefaults();
+    void restoreDefaults();
     /// Clear all input configuration
     void ClearAll();
 
     /// Update UI to reflect current configuration.
-    void UpdateButtonLabels();
+    void updateButtonLabels();
 
     /// Called when the button was pressed.
-    void HandleClick(QPushButton* button,
+    void handleClick(QPushButton* button,
                      std::function<void(const Common::ParamPackage&)> new_input_setter,
                      InputCommon::Polling::DeviceType type);
 
     /// Finish polling and configure input using the input_setter
-    void SetPollingResult(const Common::ParamPackage& params, bool abort);
+    void setPollingResult(const Common::ParamPackage& params, bool abort);
 
     /// Handle key press events.
     void keyPressEvent(QKeyEvent* event) override;

src/yuzu/configuration/configure_input_simple.cpp

@@ -15,12 +15,12 @@ namespace {
 
 template <typename Dialog, typename... Args>
 void CallConfigureDialog(ConfigureInputSimple* caller, Args&&... args) {
-    caller->ApplyConfiguration();
+    caller->applyConfiguration();
     Dialog dialog(caller, std::forward<Args>(args)...);
 
     const auto res = dialog.exec();
     if (res == QDialog::Accepted) {
-        dialog.ApplyConfiguration();
+        dialog.applyConfiguration();
     }
 }
 
@@ -103,41 +103,27 @@ ConfigureInputSimple::ConfigureInputSimple(QWidget* parent)
             &ConfigureInputSimple::OnSelectProfile);
     connect(ui->profile_configure, &QPushButton::pressed, this, &ConfigureInputSimple::OnConfigure);
 
-    LoadConfiguration();
+    this->loadConfiguration();
 }
 
 ConfigureInputSimple::~ConfigureInputSimple() = default;
 
-void ConfigureInputSimple::ApplyConfiguration() {
+void ConfigureInputSimple::applyConfiguration() {
     auto index = ui->profile_combobox->currentIndex();
     // Make the stored index for "Custom" very large so that if new profiles are added it
     // doesn't change.
-    if (index >= static_cast<int>(INPUT_PROFILES.size() - 1)) {
+    if (index >= static_cast<int>(INPUT_PROFILES.size() - 1))
         index = std::numeric_limits<int>::max();
-    }
 
     UISettings::values.profile_index = index;
 }
 
-void ConfigureInputSimple::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QWidget::changeEvent(event);
-}
-
-void ConfigureInputSimple::RetranslateUI() {
-    ui->retranslateUi(this);
-}
-
-void ConfigureInputSimple::LoadConfiguration() {
+void ConfigureInputSimple::loadConfiguration() {
     const auto index = UISettings::values.profile_index;
-    if (index >= static_cast<int>(INPUT_PROFILES.size()) || index < 0) {
+    if (index >= static_cast<int>(INPUT_PROFILES.size()) || index < 0)
         ui->profile_combobox->setCurrentIndex(static_cast<int>(INPUT_PROFILES.size() - 1));
-    } else {
+    else
         ui->profile_combobox->setCurrentIndex(index);
-    }
 }
 
 void ConfigureInputSimple::OnSelectProfile(int index) {

src/yuzu/configuration/configure_input_simple.h

@@ -27,14 +27,11 @@ public:
     ~ConfigureInputSimple() override;
 
     /// Save all button configurations to settings file
-    void ApplyConfiguration();
+    void applyConfiguration();
 
 private:
-    void changeEvent(QEvent* event) override;
-    void RetranslateUI();
-
     /// Load configuration settings.
-    void LoadConfiguration();
+    void loadConfiguration();
 
     void OnSelectProfile(int index);
     void OnConfigure();

src/yuzu/configuration/configure_mouse_advanced.cpp

@@ -84,7 +84,7 @@ ConfigureMouseAdvanced::ConfigureMouseAdvanced(QWidget* parent)
 
         button->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(button, &QPushButton::released, [=] {
-            HandleClick(
+            handleClick(
                 button_map[button_id],
                 [=](const Common::ParamPackage& params) { buttons_param[button_id] = params; },
                 InputCommon::Polling::DeviceType::Button);
@@ -105,60 +105,48 @@ ConfigureMouseAdvanced::ConfigureMouseAdvanced(QWidget* parent)
     }
 
     connect(ui->buttonClearAll, &QPushButton::released, [this] { ClearAll(); });
-    connect(ui->buttonRestoreDefaults, &QPushButton::released, [this] { RestoreDefaults(); });
+    connect(ui->buttonRestoreDefaults, &QPushButton::released, [this]() { restoreDefaults(); });
 
     timeout_timer->setSingleShot(true);
-    connect(timeout_timer.get(), &QTimer::timeout, [this] { SetPollingResult({}, true); });
+    connect(timeout_timer.get(), &QTimer::timeout, [this]() { setPollingResult({}, true); });
 
-    connect(poll_timer.get(), &QTimer::timeout, [this] {
+    connect(poll_timer.get(), &QTimer::timeout, [this]() {
         Common::ParamPackage params;
         for (auto& poller : device_pollers) {
             params = poller->GetNextInput();
             if (params.Has("engine")) {
-                SetPollingResult(params, false);
+                setPollingResult(params, false);
                 return;
             }
         }
     });
 
-    LoadConfiguration();
+    loadConfiguration();
     resize(0, 0);
 }
 
 ConfigureMouseAdvanced::~ConfigureMouseAdvanced() = default;
 
-void ConfigureMouseAdvanced::ApplyConfiguration() {
+void ConfigureMouseAdvanced::applyConfiguration() {
     std::transform(buttons_param.begin(), buttons_param.end(),
                    Settings::values.mouse_buttons.begin(),
                    [](const Common::ParamPackage& param) { return param.Serialize(); });
 }
 
-void ConfigureMouseAdvanced::LoadConfiguration() {
+void ConfigureMouseAdvanced::loadConfiguration() {
     std::transform(Settings::values.mouse_buttons.begin(), Settings::values.mouse_buttons.end(),
                    buttons_param.begin(),
                    [](const std::string& str) { return Common::ParamPackage(str); });
-    UpdateButtonLabels();
+    updateButtonLabels();
 }
 
-void ConfigureMouseAdvanced::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QDialog::changeEvent(event);
-}
-
-void ConfigureMouseAdvanced::RetranslateUI() {
-    ui->retranslateUi(this);
-}
-
-void ConfigureMouseAdvanced::RestoreDefaults() {
+void ConfigureMouseAdvanced::restoreDefaults() {
     for (int button_id = 0; button_id < Settings::NativeMouseButton::NumMouseButtons; button_id++) {
         buttons_param[button_id] = Common::ParamPackage{
             InputCommon::GenerateKeyboardParam(Config::default_mouse_buttons[button_id])};
     }
 
-    UpdateButtonLabels();
+    updateButtonLabels();
 }
 
 void ConfigureMouseAdvanced::ClearAll() {
@@ -169,16 +157,16 @@ void ConfigureMouseAdvanced::ClearAll() {
         }
     }
 
-    UpdateButtonLabels();
+    updateButtonLabels();
 }
 
-void ConfigureMouseAdvanced::UpdateButtonLabels() {
+void ConfigureMouseAdvanced::updateButtonLabels() {
     for (int button = 0; button < Settings::NativeMouseButton::NumMouseButtons; button++) {
         button_map[button]->setText(ButtonToText(buttons_param[button]));
     }
 }
 
-void ConfigureMouseAdvanced::HandleClick(
+void ConfigureMouseAdvanced::handleClick(
     QPushButton* button, std::function<void(const Common::ParamPackage&)> new_input_setter,
     InputCommon::Polling::DeviceType type) {
     button->setText(tr("[press key]"));
@@ -206,7 +194,7 @@ void ConfigureMouseAdvanced::HandleClick(
     poll_timer->start(200);     // Check for new inputs every 200ms
 }
 
-void ConfigureMouseAdvanced::SetPollingResult(const Common::ParamPackage& params, bool abort) {
+void ConfigureMouseAdvanced::setPollingResult(const Common::ParamPackage& params, bool abort) {
     releaseKeyboard();
     releaseMouse();
     timeout_timer->stop();
@@ -219,23 +207,22 @@ void ConfigureMouseAdvanced::SetPollingResult(const Common::ParamPackage& params
         (*input_setter)(params);
     }
 
-    UpdateButtonLabels();
+    updateButtonLabels();
     input_setter = std::nullopt;
 }
 
 void ConfigureMouseAdvanced::keyPressEvent(QKeyEvent* event) {
-    if (!input_setter || !event) {
+    if (!input_setter || !event)
         return;
-    }
 
     if (event->key() != Qt::Key_Escape) {
         if (want_keyboard_keys) {
-            SetPollingResult(Common::ParamPackage{InputCommon::GenerateKeyboardParam(event->key())},
+            setPollingResult(Common::ParamPackage{InputCommon::GenerateKeyboardParam(event->key())},
                              false);
         } else {
             // Escape key wasn't pressed and we don't want any keyboard keys, so don't stop polling
             return;
         }
     }
-    SetPollingResult({}, true);
+    setPollingResult({}, true);
 }

src/yuzu/configuration/configure_mouse_advanced.h

@@ -25,29 +25,26 @@ public:
     explicit ConfigureMouseAdvanced(QWidget* parent);
     ~ConfigureMouseAdvanced() override;
 
-    void ApplyConfiguration();
+    void applyConfiguration();
 
 private:
-    void changeEvent(QEvent* event) override;
-    void RetranslateUI();
-
     /// Load configuration settings.
-    void LoadConfiguration();
+    void loadConfiguration();
     /// Restore all buttons to their default values.
-    void RestoreDefaults();
+    void restoreDefaults();
     /// Clear all input configuration
     void ClearAll();
 
     /// Update UI to reflect current configuration.
-    void UpdateButtonLabels();
+    void updateButtonLabels();
 
     /// Called when the button was pressed.
-    void HandleClick(QPushButton* button,
+    void handleClick(QPushButton* button,
                      std::function<void(const Common::ParamPackage&)> new_input_setter,
                      InputCommon::Polling::DeviceType type);
 
     /// Finish polling and configure input using the input_setter
-    void SetPollingResult(const Common::ParamPackage& params, bool abort);
+    void setPollingResult(const Common::ParamPackage& params, bool abort);
 
     /// Handle key press events.
     void keyPressEvent(QKeyEvent* event) override;