gl_rasterizer: Force depth testing when depth mask is enabled

This is a workaround for an OpenGL weird design choice where the
depth buffer is not changed unless depth testing is enabled.

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+patreon: yuzuteam

CMakeModules/GenerateSCMRev.cmake

@@ -82,6 +82,9 @@ set(HASH_FILES
     "${VIDEO_CORE}/shader/decode/video.cpp"
     "${VIDEO_CORE}/shader/decode/xmad.cpp"
     "${VIDEO_CORE}/shader/decode.cpp"
+    "${VIDEO_CORE}/shader/node.h"
+    "${VIDEO_CORE}/shader/node_helper.cpp"
+    "${VIDEO_CORE}/shader/node_helper.h"
     "${VIDEO_CORE}/shader/shader_ir.cpp"
     "${VIDEO_CORE}/shader/shader_ir.h"
     "${VIDEO_CORE}/shader/track.cpp"

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. At this time, yuzu cannot play any commercial games without major problems. 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. 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,7 +57,9 @@ Stream::State Stream::GetState() const {
 
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
     const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
-    return Core::Timing::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
+    const auto us =
+        std::chrono::microseconds((static_cast<u64>(num_samples) * 1000000) / sample_rate);
+    return Core::Timing::usToCycles(us);
 }
 
 static void VolumeAdjustSamples(std::vector<s16>& samples) {

src/common/CMakeLists.txt

@@ -56,6 +56,9 @@ add_custom_command(OUTPUT scm_rev.cpp
       "${VIDEO_CORE}/shader/decode/video.cpp"
       "${VIDEO_CORE}/shader/decode/xmad.cpp"
       "${VIDEO_CORE}/shader/decode.cpp"
+      "${VIDEO_CORE}/shader/node.h"
+      "${VIDEO_CORE}/shader/node_helper.cpp"
+      "${VIDEO_CORE}/shader/node_helper.h"
       "${VIDEO_CORE}/shader/shader_ir.cpp"
       "${VIDEO_CORE}/shader/shader_ir.h"
       "${VIDEO_CORE}/shader/track.cpp"
@@ -123,6 +126,8 @@ 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/hex_util.cpp

@@ -30,13 +30,6 @@ std::vector<u8> HexStringToVector(std::string_view str, bool little_endian) {
     return out;
 }
 
-std::string HexVectorToString(const std::vector<u8>& vector, bool upper) {
-    std::string out;
-    for (u8 c : vector)
-        out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
-    return out;
-}
-
 std::array<u8, 16> operator""_array16(const char* str, std::size_t len) {
     if (len != 32) {
         LOG_ERROR(Common,

src/common/hex_util.h

@@ -7,6 +7,7 @@
 #include <array>
 #include <cstddef>
 #include <string>
+#include <type_traits>
 #include <vector>
 #include <fmt/format.h>
 #include "common/common_types.h"
@@ -30,13 +31,20 @@ std::array<u8, Size> HexStringToArray(std::string_view str) {
     return out;
 }
 
-std::string HexVectorToString(const std::vector<u8>& vector, bool upper = true);
+template <typename ContiguousContainer>
+std::string HexToString(const ContiguousContainer& data, bool upper = true) {
+    static_assert(std::is_same_v<typename ContiguousContainer::value_type, u8>,
+                  "Underlying type within the contiguous container must be u8.");
+
+    constexpr std::size_t pad_width = 2;
 
-template <std::size_t Size>
-std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
     std::string out;
-    for (u8 c : array)
+    out.reserve(std::size(data) * pad_width);
+
+    for (const u8 c : data) {
         out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
+    }
+
     return out;
 }
 

src/common/math_util.h

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

src/common/uuid.cpp

@@ -0,0 +1,33 @@
+// 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

@@ -0,0 +1,48 @@
+// 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

@@ -5,6 +5,8 @@ add_library(core STATIC
     arm/exclusive_monitor.h
     arm/unicorn/arm_unicorn.cpp
     arm/unicorn/arm_unicorn.h
+    constants.cpp
+    constants.h
     core.cpp
     core.h
     core_cpu.cpp
@@ -310,6 +312,8 @@ 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
@@ -326,6 +330,9 @@ 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/constants.cpp

@@ -0,0 +1,17 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/constants.h"
+
+namespace Core::Constants {
+const std::array<u8, 107> ACCOUNT_BACKUP_JPEG{{
+    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
+    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
+    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
+    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
+    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
+    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
+    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
+}};
+}

src/core/constants.h

@@ -0,0 +1,17 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+// This is to consolidate system-wide constants that are used by multiple components of yuzu.
+// This is especially to prevent the case of something in frontend duplicating a constexpr array or
+// directly including some service header for the sole purpose of data.
+namespace Core::Constants {
+
+// ACC Service - Blank JPEG used as user icon in absentia of real one.
+extern const std::array<u8, 107> ACCOUNT_BACKUP_JPEG;
+
+} // namespace Core::Constants

src/core/core.cpp

@@ -18,11 +18,6 @@
 #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"
@@ -37,9 +32,6 @@
 #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"
@@ -144,20 +136,10 @@ 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) {
@@ -167,6 +149,7 @@ 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,7 +98,6 @@ 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,52 +13,40 @@ namespace Core::Timing {
 
 constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
-s64 usToCycles(s64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+s64 msToCycles(std::chrono::milliseconds ms) {
+    if (static_cast<u64>(ms.count() / 1000) > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
+    if (static_cast<u64>(ms.count()) > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (us / 1000000);
+        return BASE_CLOCK_RATE * (ms.count() / 1000);
     }
-    return (BASE_CLOCK_RATE * us) / 1000000;
+    return (BASE_CLOCK_RATE * ms.count()) / 1000;
 }
 
-s64 usToCycles(u64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+s64 usToCycles(std::chrono::microseconds us) {
+    if (static_cast<u64>(us.count() / 1000000) > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
+    if (static_cast<u64>(us.count()) > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        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;
+    return (BASE_CLOCK_RATE * us.count()) / 1000000;
 }
 
-s64 nsToCycles(s64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+s64 nsToCycles(std::chrono::nanoseconds ns) {
+    if (static_cast<u64>(ns.count() / 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) {
+    if (static_cast<u64>(ns.count()) > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        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;
+    return (BASE_CLOCK_RATE * ns.count()) / 1000000000;
 }
 
 u64 CpuCyclesToClockCycles(u64 ticks) {

src/core/core_timing_util.h

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

src/core/crypto/key_manager.cpp

@@ -572,7 +572,7 @@ void KeyManager::WriteKeyToFile(KeyCategory category, std::string_view keyname,
             << "# If you are experiencing issues involving keys, it may help to delete this file\n";
     }
 
-    file << fmt::format("\n{} = {}", keyname, Common::HexArrayToString(key));
+    file << fmt::format("\n{} = {}", keyname, Common::HexToString(key));
     AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, filename, category == KeyCategory::Title);
 }
 
@@ -583,7 +583,7 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
         Key128 rights_id;
         std::memcpy(rights_id.data(), &field2, sizeof(u64));
         std::memcpy(rights_id.data() + sizeof(u64), &field1, sizeof(u64));
-        WriteKeyToFile(KeyCategory::Title, Common::HexArrayToString(rights_id), key);
+        WriteKeyToFile(KeyCategory::Title, Common::HexToString(rights_id), key);
     }
 
     auto category = KeyCategory::Standard;

src/core/file_sys/card_image.cpp

@@ -18,11 +18,16 @@
 
 namespace FileSys {
 
-constexpr std::array<const char*, 0x4> partition_names = {"update", "normal", "secure", "logo"};
+constexpr std::array partition_names{
+    "update",
+    "normal",
+    "secure",
+    "logo",
+};
 
 XCI::XCI(VirtualFile file_)
     : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
-      partitions(0x4) {
+      partitions(partition_names.size()) {
     if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
         status = Loader::ResultStatus::ErrorBadXCIHeader;
         return;
@@ -43,23 +48,24 @@ XCI::XCI(VirtualFile file_)
 
     for (XCIPartition partition :
          {XCIPartition::Update, XCIPartition::Normal, XCIPartition::Secure, XCIPartition::Logo}) {
-        auto raw = main_hfs.GetFile(partition_names[static_cast<std::size_t>(partition)]);
-        if (raw != nullptr)
-            partitions[static_cast<std::size_t>(partition)] =
-                std::make_shared<PartitionFilesystem>(raw);
+        const auto partition_idx = static_cast<std::size_t>(partition);
+        auto raw = main_hfs.GetFile(partition_names[partition_idx]);
+
+        if (raw != nullptr) {
+            partitions[partition_idx] = std::make_shared<PartitionFilesystem>(std::move(raw));
+        }
     }
 
     secure_partition = std::make_shared<NSP>(
         main_hfs.GetFile(partition_names[static_cast<std::size_t>(XCIPartition::Secure)]));
 
-    const auto secure_ncas = secure_partition->GetNCAsCollapsed();
-    std::copy(secure_ncas.begin(), secure_ncas.end(), std::back_inserter(ncas));
-
+    ncas = secure_partition->GetNCAsCollapsed();
     program =
         secure_partition->GetNCA(secure_partition->GetProgramTitleID(), ContentRecordType::Program);
     program_nca_status = secure_partition->GetProgramStatus(secure_partition->GetProgramTitleID());
-    if (program_nca_status == Loader::ResultStatus::ErrorNSPMissingProgramNCA)
+    if (program_nca_status == Loader::ResultStatus::ErrorNSPMissingProgramNCA) {
         program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
+    }
 
     auto result = AddNCAFromPartition(XCIPartition::Update);
     if (result != Loader::ResultStatus::Success) {
@@ -147,8 +153,9 @@ std::shared_ptr<NCA> XCI::GetNCAByType(NCAContentType type) const {
 
 VirtualFile XCI::GetNCAFileByType(NCAContentType type) const {
     auto nca = GetNCAByType(type);
-    if (nca != nullptr)
+    if (nca != nullptr) {
         return nca->GetBaseFile();
+    }
     return nullptr;
 }
 
@@ -169,17 +176,22 @@ VirtualDir XCI::GetParentDirectory() const {
 }
 
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
-    if (partitions[static_cast<std::size_t>(part)] == nullptr) {
+    const auto partition_index = static_cast<std::size_t>(part);
+    const auto& partition = partitions[partition_index];
+
+    if (partition == nullptr) {
         return Loader::ResultStatus::ErrorXCIMissingPartition;
     }
 
-    for (const VirtualFile& file : partitions[static_cast<std::size_t>(part)]->GetFiles()) {
-        if (file->GetExtension() != "nca")
+    for (const VirtualFile& file : partition->GetFiles()) {
+        if (file->GetExtension() != "nca") {
             continue;
+        }
+
         auto nca = std::make_shared<NCA>(file, nullptr, 0, keys);
-        // TODO(DarkLordZach): Add proper Rev1+ Support
-        if (nca->IsUpdate())
+        if (nca->IsUpdate()) {
             continue;
+        }
         if (nca->GetType() == NCAContentType::Program) {
             program_nca_status = nca->GetStatus();
         }
@@ -188,7 +200,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
         } else {
             const u16 error_id = static_cast<u16>(nca->GetStatus());
             LOG_CRITICAL(Loader, "Could not load NCA {}/{}, failed with error code {:04X} ({})",
-                         partition_names[static_cast<std::size_t>(part)], nca->GetName(), error_id,
+                         partition_names[partition_index], nca->GetName(), error_id,
                          nca->GetStatus());
         }
     }

src/core/file_sys/control_metadata.cpp

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

src/core/file_sys/ips_layer.cpp

@@ -287,7 +287,6 @@ void IPSwitchCompiler::Parse() {
                 } else {
                     // hex replacement
                     const auto value = patch_line.substr(9);
-                    replace.reserve(value.size() / 2);
                     replace = Common::HexStringToVector(value, is_little_endian);
                 }
 
@@ -295,7 +294,7 @@ void IPSwitchCompiler::Parse() {
                     LOG_INFO(Loader,
                              "[IPSwitchCompiler ('{}')]     - Patching value at offset 0x{:08X} "
                              "with byte string '{}'",
-                             patch_text->GetName(), offset, Common::HexVectorToString(replace));
+                             patch_text->GetName(), offset, Common::HexToString(replace));
                 }
 
                 patch.records.insert_or_assign(offset, std::move(replace));

src/core/file_sys/nca_metadata.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <array>
 #include <memory>
 #include <vector>
 #include "common/common_funcs.h"
@@ -69,11 +70,15 @@ struct CNMTHeader {
     u64_le title_id;
     u32_le title_version;
     TitleType type;
-    INSERT_PADDING_BYTES(1);
+    u8 reserved;
     u16_le table_offset;
     u16_le number_content_entries;
     u16_le number_meta_entries;
-    INSERT_PADDING_BYTES(12);
+    u8 attributes;
+    std::array<u8, 2> reserved2;
+    u8 is_committed;
+    u32_le required_download_system_version;
+    std::array<u8, 4> reserved3;
 };
 static_assert(sizeof(CNMTHeader) == 0x20, "CNMTHeader has incorrect size.");
 

src/core/file_sys/patch_manager.cpp

@@ -142,7 +142,7 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
                     if (!compiler.IsValid())
                         continue;
 
-                    auto this_build_id = Common::HexArrayToString(compiler.GetBuildID());
+                    auto this_build_id = Common::HexToString(compiler.GetBuildID());
                     this_build_id =
                         this_build_id.substr(0, this_build_id.find_last_not_of('0') + 1);
 
@@ -168,7 +168,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
         return nso;
     }
 
-    const auto build_id_raw = Common::HexArrayToString(header.build_id);
+    const auto build_id_raw = Common::HexToString(header.build_id);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
 
     if (Settings::values.dump_nso) {
@@ -219,7 +219,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
 }
 
 bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
-    const auto build_id_raw = Common::HexArrayToString(build_id_);
+    const auto build_id_raw = Common::HexToString(build_id_);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
 
     LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);
@@ -235,7 +235,7 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
 static std::optional<CheatList> ReadCheatFileFromFolder(const Core::System& system, u64 title_id,
                                                         const std::array<u8, 0x20>& build_id_,
                                                         const VirtualDir& base_path, bool upper) {
-    const auto build_id_raw = Common::HexArrayToString(build_id_, upper);
+    const auto build_id_raw = Common::HexToString(build_id_, upper);
     const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
     const auto file = base_path->GetFile(fmt::format("{}.txt", build_id));
 

src/core/file_sys/registered_cache.cpp

@@ -53,13 +53,14 @@ static bool FollowsNcaIdFormat(std::string_view name) {
 
 static std::string GetRelativePathFromNcaID(const std::array<u8, 16>& nca_id, bool second_hex_upper,
                                             bool within_two_digit) {
-    if (!within_two_digit)
-        return fmt::format("/{}.nca", Common::HexArrayToString(nca_id, second_hex_upper));
+    if (!within_two_digit) {
+        return fmt::format("/{}.nca", Common::HexToString(nca_id, second_hex_upper));
+    }
 
     Core::Crypto::SHA256Hash hash{};
     mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
     return fmt::format("/000000{:02X}/{}.nca", hash[0],
-                       Common::HexArrayToString(nca_id, second_hex_upper));
+                       Common::HexToString(nca_id, second_hex_upper));
 }
 
 static std::string GetCNMTName(TitleType type, u64 title_id) {
@@ -376,10 +377,11 @@ std::vector<ContentProviderEntry> RegisteredCache::ListEntriesFilter(
 }
 
 static std::shared_ptr<NCA> GetNCAFromNSPForID(const NSP& nsp, const NcaID& id) {
-    const auto file = nsp.GetFile(fmt::format("{}.nca", Common::HexArrayToString(id, false)));
-    if (file == nullptr)
+    auto file = nsp.GetFile(fmt::format("{}.nca", Common::HexToString(id, false)));
+    if (file == nullptr) {
         return nullptr;
-    return std::make_shared<NCA>(file);
+    }
+    return std::make_shared<NCA>(std::move(file));
 }
 
 InstallResult RegisteredCache::InstallEntry(const XCI& xci, bool overwrite_if_exists,

src/core/file_sys/submission_package.cpp

@@ -235,16 +235,18 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
         const auto section0 = nca->GetSubdirectories()[0];
 
         for (const auto& inner_file : section0->GetFiles()) {
-            if (inner_file->GetExtension() != "cnmt")
+            if (inner_file->GetExtension() != "cnmt") {
                 continue;
+            }
 
             const CNMT cnmt(inner_file);
             auto& ncas_title = ncas[cnmt.GetTitleID()];
 
             ncas_title[{cnmt.GetType(), ContentRecordType::Meta}] = nca;
             for (const auto& rec : cnmt.GetContentRecords()) {
-                const auto id_string = Common::HexArrayToString(rec.nca_id, false);
-                const auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
+                const auto id_string = Common::HexToString(rec.nca_id, false);
+                auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
+
                 if (next_file == nullptr) {
                     LOG_WARNING(Service_FS,
                                 "NCA with ID {}.nca is listed in content metadata, but cannot "
@@ -253,9 +255,10 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                     continue;
                 }
 
-                auto next_nca = std::make_shared<NCA>(next_file, nullptr, 0, keys);
-                if (next_nca->GetType() == NCAContentType::Program)
+                auto next_nca = std::make_shared<NCA>(std::move(next_file), nullptr, 0, keys);
+                if (next_nca->GetType() == NCAContentType::Program) {
                     program_status[cnmt.GetTitleID()] = next_nca->GetStatus();
+                }
                 if (next_nca->GetStatus() == Loader::ResultStatus::Success ||
                     (next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
                      (cnmt.GetTitleID() & 0x800) != 0)) {

src/core/file_sys/xts_archive.cpp

@@ -66,7 +66,7 @@ NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
     Core::Crypto::SHA256Hash hash{};
     mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
     status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],
-                               Common::HexArrayToString(nca_id, false)));
+                               Common::HexToString(nca_id, false)));
 }
 
 NAX::~NAX() = default;

src/core/frontend/applets/profile_select.cpp

@@ -3,6 +3,7 @@
 // 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 {
@@ -10,9 +11,9 @@ namespace Core::Frontend {
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
 void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Service::Account::UUID>)> callback) const {
+    std::function<void(std::optional<Common::UUID>)> callback) const {
     Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user).value_or(Service::Account::UUID{}));
+    callback(manager.GetUser(Settings::values.current_user).value_or(Common::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 "core/hle/service/acc/profile_manager.h"
+#include "common/uuid.h"
 
 namespace Core::Frontend {
 
@@ -14,14 +14,12 @@ class ProfileSelectApplet {
 public:
     virtual ~ProfileSelectApplet();
 
-    virtual void SelectProfile(
-        std::function<void(std::optional<Service::Account::UUID>)> callback) const = 0;
+    virtual void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const = 0;
 };
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
-    void SelectProfile(
-        std::function<void(std::optional<Service::Account::UUID>)> callback) const override;
+    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/emu_window.h

@@ -169,8 +169,7 @@ private:
      * For the request to be honored, EmuWindow implementations will usually reimplement this
      * function.
      */
-    virtual void OnMinimalClientAreaChangeRequest(
-        const std::pair<unsigned, unsigned>& minimal_size) {
+    virtual void OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned>) {
         // By default, ignore this request and do nothing.
     }
 

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(unsigned width, unsigned height) {
+FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
     ASSERT(width > 0);
     ASSERT(height > 0);
     // The drawing code needs at least somewhat valid values for both screens
@@ -29,22 +29,23 @@ FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
 
     const float emulation_aspect_ratio{static_cast<float>(ScreenUndocked::Height) /
                                        ScreenUndocked::Width};
-    Common::Rectangle<unsigned> screen_window_area{0, 0, width, height};
-    Common::Rectangle<unsigned> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
+    const auto window_aspect_ratio = static_cast<float>(height) / width;
 
-    float window_aspect_ratio = static_cast<float>(height) / width;
+    const Common::Rectangle<u32> screen_window_area{0, 0, width, height};
+    Common::Rectangle<u32> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
 
     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(u16 res_scale) {
-    int width, height;
+FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
+    u32 width, height;
 
     if (Settings::values.use_docked_mode) {
         width = ScreenDocked::WidthDocked * res_scale;

src/core/frontend/framebuffer_layout.h

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

src/core/hle/kernel/process.cpp

@@ -48,7 +48,7 @@ void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority) {
 }
 } // Anonymous namespace
 
-SharedPtr<Process> Process::Create(Core::System& system, std::string&& name) {
+SharedPtr<Process> Process::Create(Core::System& system, std::string name) {
     auto& kernel = system.Kernel();
 
     SharedPtr<Process> process(new Process(system));
@@ -72,10 +72,26 @@ SharedPtr<ResourceLimit> Process::GetResourceLimit() const {
     return resource_limit;
 }
 
+u64 Process::GetTotalPhysicalMemoryAvailable() const {
+    return vm_manager.GetTotalPhysicalMemoryAvailable();
+}
+
+u64 Process::GetTotalPhysicalMemoryAvailableWithoutMmHeap() const {
+    // TODO: Subtract the personal heap size from this when the
+    //       personal heap is implemented.
+    return GetTotalPhysicalMemoryAvailable();
+}
+
 u64 Process::GetTotalPhysicalMemoryUsed() const {
     return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size;
 }
 
+u64 Process::GetTotalPhysicalMemoryUsedWithoutMmHeap() const {
+    // TODO: Subtract the personal heap size from this when the
+    //       personal heap is implemented.
+    return GetTotalPhysicalMemoryUsed();
+}
+
 void Process::RegisterThread(const Thread* thread) {
     thread_list.push_back(thread);
 }

src/core/hle/kernel/process.h

@@ -10,7 +10,6 @@
 #include <list>
 #include <string>
 #include <vector>
-#include <boost/container/static_vector.hpp>
 #include "common/common_types.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/handle_table.h"
@@ -76,7 +75,7 @@ public:
 
     static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
 
-    static SharedPtr<Process> Create(Core::System& system, std::string&& name);
+    static SharedPtr<Process> Create(Core::System& system, std::string name);
 
     std::string GetTypeName() const override {
         return "Process";
@@ -187,9 +186,20 @@ public:
         return random_entropy.at(index);
     }
 
+    /// Retrieves the total physical memory available to this process in bytes.
+    u64 GetTotalPhysicalMemoryAvailable() const;
+
+    /// Retrieves the total physical memory available to this process in bytes,
+    /// without the size of the personal heap added to it.
+    u64 GetTotalPhysicalMemoryAvailableWithoutMmHeap() const;
+
     /// Retrieves the total physical memory used by this process in bytes.
     u64 GetTotalPhysicalMemoryUsed() const;
 
+    /// Retrieves the total physical memory used by this process in bytes,
+    /// without the size of the personal heap added to it.
+    u64 GetTotalPhysicalMemoryUsedWithoutMmHeap() const;
+
     /// Gets the list of all threads created with this process as their owner.
     const std::list<const Thread*>& GetThreadList() const {
         return thread_list;

src/core/hle/kernel/svc.cpp

@@ -710,13 +710,13 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
         MapRegionSize = 3,
         HeapRegionBaseAddr = 4,
         HeapRegionSize = 5,
-        TotalMemoryUsage = 6,
+        TotalPhysicalMemoryAvailable = 6,
         TotalPhysicalMemoryUsed = 7,
         IsCurrentProcessBeingDebugged = 8,
         RegisterResourceLimit = 9,
         IdleTickCount = 10,
         RandomEntropy = 11,
-        PerformanceCounter = 0xF0000002,
+        ThreadTickCount = 0xF0000002,
         // 2.0.0+
         ASLRRegionBaseAddr = 12,
         ASLRRegionSize = 13,
@@ -730,7 +730,9 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
         PrivilegedProcessId = 19,
         // 5.0.0+
         UserExceptionContextAddr = 20,
-        ThreadTickCount = 0xF0000002,
+        // 6.0.0+
+        TotalPhysicalMemoryAvailableWithoutMmHeap = 21,
+        TotalPhysicalMemoryUsedWithoutMmHeap = 22,
     };
 
     const auto info_id_type = static_cast<GetInfoType>(info_id);
@@ -746,12 +748,14 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
     case GetInfoType::ASLRRegionSize:
     case GetInfoType::NewMapRegionBaseAddr:
     case GetInfoType::NewMapRegionSize:
-    case GetInfoType::TotalMemoryUsage:
+    case GetInfoType::TotalPhysicalMemoryAvailable:
     case GetInfoType::TotalPhysicalMemoryUsed:
     case GetInfoType::IsVirtualAddressMemoryEnabled:
     case GetInfoType::PersonalMmHeapUsage:
     case GetInfoType::TitleId:
-    case GetInfoType::UserExceptionContextAddr: {
+    case GetInfoType::UserExceptionContextAddr:
+    case GetInfoType::TotalPhysicalMemoryAvailableWithoutMmHeap:
+    case GetInfoType::TotalPhysicalMemoryUsedWithoutMmHeap: {
         if (info_sub_id != 0) {
             return ERR_INVALID_ENUM_VALUE;
         }
@@ -804,8 +808,8 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
             *result = process->VMManager().GetNewMapRegionSize();
             return RESULT_SUCCESS;
 
-        case GetInfoType::TotalMemoryUsage:
-            *result = process->VMManager().GetTotalMemoryUsage();
+        case GetInfoType::TotalPhysicalMemoryAvailable:
+            *result = process->GetTotalPhysicalMemoryAvailable();
             return RESULT_SUCCESS;
 
         case GetInfoType::TotalPhysicalMemoryUsed:
@@ -826,6 +830,14 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
             *result = 0;
             return RESULT_SUCCESS;
 
+        case GetInfoType::TotalPhysicalMemoryAvailableWithoutMmHeap:
+            *result = process->GetTotalPhysicalMemoryAvailable();
+            return RESULT_SUCCESS;
+
+        case GetInfoType::TotalPhysicalMemoryUsedWithoutMmHeap:
+            *result = process->GetTotalPhysicalMemoryUsedWithoutMmHeap();
+            return RESULT_SUCCESS;
+
         default:
             break;
         }

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(
-        Core::Timing::nsToCycles(nanoseconds), kernel.ThreadWakeupCallbackEventType(),
-        callback_handle);
+        cycles, kernel.ThreadWakeupCallbackEventType(), callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {

src/core/hle/kernel/vm_manager.cpp

@@ -68,9 +68,7 @@ VMManager::VMManager(Core::System& system) : system{system} {
     Reset(FileSys::ProgramAddressSpaceType::Is39Bit);
 }
 
-VMManager::~VMManager() {
-    Reset(FileSys::ProgramAddressSpaceType::Is39Bit);
-}
+VMManager::~VMManager() = default;
 
 void VMManager::Reset(FileSys::ProgramAddressSpaceType type) {
     Clear();
@@ -758,7 +756,7 @@ VMManager::CheckResults VMManager::CheckRangeState(VAddr address, u64 size, Memo
         std::make_tuple(initial_state, initial_permissions, initial_attributes & ~ignore_mask));
 }
 
-u64 VMManager::GetTotalMemoryUsage() const {
+u64 VMManager::GetTotalPhysicalMemoryAvailable() const {
     LOG_WARNING(Kernel, "(STUBBED) called");
     return 0xF8000000;
 }

src/core/hle/kernel/vm_manager.h

@@ -499,7 +499,7 @@ public:
     void LogLayout() const;
 
     /// Gets the total memory usage, used by svcGetInfo
-    u64 GetTotalMemoryUsage() const;
+    u64 GetTotalPhysicalMemoryAvailable() const;
 
     /// Gets the address space base address
     VAddr GetAddressSpaceBaseAddress() const;

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

@@ -10,6 +10,7 @@
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "common/swap.h"
+#include "core/constants.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/acc/acc.h"
@@ -21,20 +22,7 @@
 
 namespace Service::Account {
 
-// Smallest JPEG https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
-// used as a backup should the one on disk not exist
-constexpr u32 backup_jpeg_size = 107;
-constexpr std::array<u8, backup_jpeg_size> backup_jpeg{{
-    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
-    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
-    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
-    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
-    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
-    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
-    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
-}};
-
-static std::string GetImagePath(UUID uuid) {
+static std::string GetImagePath(Common::UUID uuid) {
     return FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
            "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
 }
@@ -46,7 +34,7 @@ static constexpr u32 SanitizeJPEGSize(std::size_t size) {
 
 class IProfile final : public ServiceFramework<IProfile> {
 public:
-    explicit IProfile(UUID user_id, ProfileManager& profile_manager)
+    explicit IProfile(Common::UUID user_id, ProfileManager& profile_manager)
         : ServiceFramework("IProfile"), profile_manager(profile_manager), user_id(user_id) {
         static const FunctionInfo functions[] = {
             {0, &IProfile::Get, "Get"},
@@ -101,8 +89,8 @@ private:
         if (!image.IsOpen()) {
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
-            ctx.WriteBuffer(backup_jpeg);
-            rb.Push<u32>(backup_jpeg_size);
+            ctx.WriteBuffer(Core::Constants::ACCOUNT_BACKUP_JPEG);
+            rb.Push<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size());
             return;
         }
 
@@ -124,14 +112,14 @@ private:
         if (!image.IsOpen()) {
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
-            rb.Push<u32>(backup_jpeg_size);
+            rb.Push<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size());
         } else {
             rb.Push<u32>(SanitizeJPEGSize(image.GetSize()));
         }
     }
 
     const ProfileManager& profile_manager;
-    UUID user_id; ///< The user id this profile refers to.
+    Common::UUID user_id; ///< The user id this profile refers to.
 };
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
@@ -179,7 +167,7 @@ void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
 
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    UUID user_id = rp.PopRaw<UUID>();
+    Common::UUID user_id = rp.PopRaw<Common::UUID>();
     LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 3};
@@ -205,12 +193,12 @@ void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
     LOG_INFO(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(RESULT_SUCCESS);
-    rb.PushRaw<UUID>(profile_manager->GetLastOpenedUser());
+    rb.PushRaw<Common::UUID>(profile_manager->GetLastOpenedUser());
 }
 
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    UUID user_id = rp.PopRaw<UUID>();
+    Common::UUID user_id = rp.PopRaw<Common::UUID>();
     LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -245,15 +233,15 @@ void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContex
     IPC::ResponseBuilder rb{ctx, 6};
     if (profile_manager->GetUserCount() != 1) {
         rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u128>(INVALID_UUID);
+        rb.PushRaw<u128>(Common::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 == INVALID_UUID; })) {
+                    [](const auto& user) { return user.uuid == Common::INVALID_UUID; })) {
         rb.Push(ResultCode(-1)); // TODO(ogniK): Find the correct error code
-        rb.PushRaw<u128>(INVALID_UUID);
+        rb.PushRaw<u128>(Common::INVALID_UUID);
         return;
     }
 

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

@@ -13,6 +13,8 @@
 
 namespace Service::Account {
 
+using Common::UUID;
+
 struct UserRaw {
     UUID uuid;
     UUID uuid2;
@@ -35,26 +37,6 @@ 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();
 
@@ -217,7 +199,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 != INVALID_UUID;
+    return profiles[index].user_uuid.uuid != Common::INVALID_UUID;
 }
 
 /// Opens a specific user
@@ -311,7 +293,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(INVALID_UUID)) {
+    if (!index || profile_new.user_uuid == UUID(Common::INVALID_UUID)) {
         return false;
     }
 
@@ -342,7 +324,7 @@ void ProfileManager::ParseUserSaveFile() {
     }
 
     for (const auto& user : data.users) {
-        if (user.uuid == UUID(INVALID_UUID)) {
+        if (user.uuid == UUID(Common::INVALID_UUID)) {
             continue;
         }
 

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

@@ -9,47 +9,15 @@
 
 #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<UUID, MAX_USERS>;
+using UserIDArray = std::array<Common::UUID, MAX_USERS>;
 
 /// Contains extra data related to a user.
 /// TODO: RE this structure
@@ -66,7 +34,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 {
-    UUID user_uuid;
+    Common::UUID user_uuid;
     ProfileUsername username;
     u64 creation_time;
     ProfileData data; // TODO(ognik): Work out what this is
@@ -74,7 +42,7 @@ struct ProfileInfo {
 };
 
 struct ProfileBase {
-    UUID user_uuid;
+    Common::UUID user_uuid;
     u64_le timestamp;
     ProfileUsername username;
 
@@ -96,33 +64,33 @@ public:
     ~ProfileManager();
 
     ResultCode AddUser(const ProfileInfo& user);
-    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;
+    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;
     std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
     bool GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const;
-    bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
+    bool GetProfileBase(Common::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(UUID uuid, ProfileBase& profile, ProfileData& data) const;
+    bool GetProfileBaseAndData(Common::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(UUID uuid) const;
+    bool UserExists(Common::UUID uuid) const;
     bool UserExistsIndex(std::size_t index) const;
-    void OpenUser(UUID uuid);
-    void CloseUser(UUID uuid);
+    void OpenUser(Common::UUID uuid);
+    void CloseUser(Common::UUID uuid);
     UserIDArray GetOpenUsers() const;
     UserIDArray GetAllUsers() const;
-    UUID GetLastOpenedUser() const;
+    Common::UUID GetLastOpenedUser() const;
 
     bool CanSystemRegisterUser() const;
 
-    bool RemoveUser(UUID uuid);
-    bool SetProfileBase(UUID uuid, const ProfileBase& profile_new);
+    bool RemoveUser(Common::UUID uuid);
+    bool SetProfileBase(Common::UUID uuid, const ProfileBase& profile_new);
 
 private:
     void ParseUserSaveFile();
@@ -132,7 +100,7 @@ private:
 
     std::array<ProfileInfo, MAX_USERS> profiles{};
     std::size_t user_count = 0;
-    UUID last_opened_user{INVALID_UUID};
+    Common::UUID last_opened_user{Common::INVALID_UUID};
 };
 
 }; // namespace Service::Account

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

@@ -8,6 +8,8 @@
 #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"
@@ -29,9 +31,11 @@
 #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"
 
@@ -1100,10 +1104,42 @@ 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(
-        static_cast<u64>(Service::Set::GetLanguageCodeFromIndex(Settings::values.language_index)));
+    rb.Push(*res_code);
 }
 
 void IApplicationFunctions::InitializeGamePlayRecording(Kernel::HLERequestContext& ctx) {

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

@@ -121,6 +121,21 @@ 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,11 +137,28 @@ protected:
 };
 
 struct AppletFrontendSet {
-    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;
+    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;
 };
 
 class AppletManager {

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

@@ -2,7 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <string>
+#include <string_view>
 
 #include "common/assert.h"
 #include "common/hex_util.h"
@@ -16,21 +16,21 @@
 
 namespace Service::AM::Applets {
 
-static void LogCurrentStorage(AppletDataBroker& broker, std::string prefix) {
+static void LogCurrentStorage(AppletDataBroker& broker, std::string_view prefix) {
     std::unique_ptr<IStorage> storage = broker.PopNormalDataToApplet();
     for (; storage != nullptr; storage = broker.PopNormalDataToApplet()) {
         const auto data = storage->GetData();
         LOG_INFO(Service_AM,
-                 "called (STUBBED), during {} recieved normal data with size={:08X}, data={}",
-                 prefix, data.size(), Common::HexVectorToString(data));
+                 "called (STUBBED), during {} received normal data with size={:08X}, data={}",
+                 prefix, data.size(), Common::HexToString(data));
     }
 
     storage = broker.PopInteractiveDataToApplet();
     for (; storage != nullptr; storage = broker.PopInteractiveDataToApplet()) {
         const auto data = storage->GetData();
         LOG_INFO(Service_AM,
-                 "called (STUBBED), during {} recieved interactive data with size={:08X}, data={}",
-                 prefix, data.size(), Common::HexVectorToString(data));
+                 "called (STUBBED), during {} received interactive data with size={:08X}, data={}",
+                 prefix, data.size(), Common::HexToString(data));
     }
 }
 

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

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

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

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

src/core/hle/service/ldr/ldr.cpp

@@ -310,7 +310,7 @@ public:
         if (!IsValidNROHash(hash)) {
             LOG_ERROR(Service_LDR,
                       "NRO hash is not present in any currently loaded NRRs (hash={})!",
-                      Common::HexArrayToString(hash));
+                      Common::HexToString(hash));
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERROR_MISSING_NRR_HASH);
             return;

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

@@ -4,42 +4,50 @@
 
 #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, nullptr, "IsUpdated"},
-            {1, nullptr, "IsFullDatabase"},
-            {2, nullptr, "GetCount"},
-            {3, nullptr, "Get"},
-            {4, nullptr, "Get1"},
+            {0, &IDatabaseService::IsUpdated, "IsUpdated"},
+            {1, &IDatabaseService::IsFullDatabase, "IsFullDatabase"},
+            {2, &IDatabaseService::GetCount, "GetCount"},
+            {3, &IDatabaseService::Get, "Get"},
+            {4, &IDatabaseService::Get1, "Get1"},
             {5, nullptr, "UpdateLatest"},
-            {6, nullptr, "BuildRandom"},
-            {7, nullptr, "BuildDefault"},
-            {8, nullptr, "Get2"},
-            {9, nullptr, "Get3"},
+            {6, &IDatabaseService::BuildRandom, "BuildRandom"},
+            {7, &IDatabaseService::BuildDefault, "BuildDefault"},
+            {8, &IDatabaseService::Get2, "Get2"},
+            {9, &IDatabaseService::Get3, "Get3"},
             {10, nullptr, "UpdateLatest1"},
-            {11, nullptr, "FindIndex"},
-            {12, nullptr, "Move"},
-            {13, nullptr, "AddOrReplace"},
-            {14, nullptr, "Delete"},
-            {15, nullptr, "DestroyFile"},
-            {16, nullptr, "DeleteFile"},
-            {17, nullptr, "Format"},
+            {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"},
             {18, nullptr, "Import"},
             {19, nullptr, "Export"},
             {20, nullptr, "IsBrokenDatabaseWithClearFlag"},
-            {21, nullptr, "GetIndex"},
+            {21, &IDatabaseService::GetIndex, "GetIndex"},
             {22, nullptr, "SetInterfaceVersion"},
             {23, nullptr, "Convert"},
         };
@@ -47,6 +55,305 @@ 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

@@ -0,0 +1,416 @@
+// 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

@@ -0,0 +1,273 @@
+// 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

@@ -0,0 +1,12 @@
+// 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

@@ -0,0 +1,392 @@
+// 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

@@ -0,0 +1,45 @@
+// 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,445 +7,507 @@
 #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 {
 
-class IAccountProxyInterface final : public ServiceFramework<IAccountProxyInterface> {
-public:
-    explicit IAccountProxyInterface() : ServiceFramework{"IAccountProxyInterface"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "CreateUserAccount"},
-        };
-        // clang-format on
+IAccountProxyInterface::IAccountProxyInterface() : ServiceFramework{"IAccountProxyInterface"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "CreateUserAccount"},
+    };
+    // clang-format on
 
-        RegisterHandlers(functions);
-    }
-};
+    RegisterHandlers(functions);
+}
 
-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
+IAccountProxyInterface::~IAccountProxyInterface() = default;
 
-        RegisterHandlers(functions);
-    }
+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
 
-    void GetApplicationControlData(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto flag = rp.PopRaw<u64>();
-        LOG_DEBUG(Service_NS, "called with flag={:016X}", flag);
+    RegisterHandlers(functions);
+}
 
-        const auto title_id = rp.PopRaw<u64>();
+IApplicationManagerInterface::~IApplicationManagerInterface() = default;
 
-        const auto size = ctx.GetWriteBufferSize();
+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 FileSys::PatchManager pm{title_id};
-        const auto control = pm.GetControlMetadata();
+    const auto title_id = rp.PopRaw<u64>();
 
-        std::vector<u8> out;
+    const auto size = ctx.GetWriteBufferSize();
 
-        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;
-            }
+    const FileSys::PatchManager pm{title_id};
+    const auto control = pm.GetControlMetadata();
 
-            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));
+    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;
         }
 
-        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;
-            }
+        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);
+    }
 
+    ctx.WriteBuffer(out);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u32>(static_cast<u32>(out.size()));
+}
+
+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>(static_cast<u32>(out.size()));
+        rb.Push<u32>(*res);
+    } else {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res.Code());
     }
-};
+}
 
-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
+ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
+    const u32 supported_languages) {
+    LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages);
 
-        RegisterHandlers(functions);
+    // 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;
     }
-};
-
-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);
+    const auto priority_list = GetApplicationLanguagePriorityList(*application_language);
+    if (!priority_list) {
+        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
     }
-};
 
-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);
+    // 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 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
+    return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+}
 
-        RegisterHandlers(functions);
+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());
     }
-};
+}
 
-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);
+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 IFactoryResetInterface final : public ServiceFramework<IFactoryResetInterface> {
-public:
-    explicit IFactoryResetInterface() : ServiceFramework{"IFactoryResetInterface"} {
-        // clang-format off
+    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
         static const FunctionInfo functions[] = {
             {100, nullptr, "ResetToFactorySettings"},
             {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
             {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
         };
-        // clang-format on
+    // clang-format on
 
-        RegisterHandlers(functions);
-    }
-};
+    RegisterHandlers(functions);
+}
 
-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
+IFactoryResetInterface::~IFactoryResetInterface() = default;
 
-        RegisterHandlers(functions);
-    }
+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
 
-private:
-    template <typename T>
-    void PushInterface(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NS, "called");
+    RegisterHandlers(functions);
+}
 
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<T>();
-    }
-};
+NS::~NS() = default;
+
+std::shared_ptr<IApplicationManagerInterface> NS::GetApplicationManagerInterface() const {
+    return GetInterface<IApplicationManagerInterface>();
+}
 
 class NS_DEV final : public ServiceFramework<NS_DEV> {
 public:

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

@@ -8,6 +8,88 @@
 
 namespace Service::NS {
 
+class IAccountProxyInterface final : public ServiceFramework<IAccountProxyInterface> {
+public:
+    explicit IAccountProxyInterface();
+    ~IAccountProxyInterface() override;
+};
+
+class IApplicationManagerInterface final : public ServiceFramework<IApplicationManagerInterface> {
+public:
+    explicit IApplicationManagerInterface();
+    ~IApplicationManagerInterface() override;
+
+    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() override;
+};
+
+class IContentManagerInterface final : public ServiceFramework<IContentManagerInterface> {
+public:
+    explicit IContentManagerInterface();
+    ~IContentManagerInterface() override;
+};
+
+class IDocumentInterface final : public ServiceFramework<IDocumentInterface> {
+public:
+    explicit IDocumentInterface();
+    ~IDocumentInterface() override;
+};
+
+class IDownloadTaskInterface final : public ServiceFramework<IDownloadTaskInterface> {
+public:
+    explicit IDownloadTaskInterface();
+    ~IDownloadTaskInterface() override;
+};
+
+class IECommerceInterface final : public ServiceFramework<IECommerceInterface> {
+public:
+    explicit IECommerceInterface();
+    ~IECommerceInterface() override;
+};
+
+class IFactoryResetInterface final : public ServiceFramework<IFactoryResetInterface> {
+public:
+    explicit IFactoryResetInterface();
+    ~IFactoryResetInterface() override;
+};
+
+class NS final : public ServiceFramework<NS> {
+public:
+    explicit NS(const char* name);
+    ~NS() override;
+
+    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

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

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

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

src/core/loader/loader.h

@@ -153,17 +153,6 @@ 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/loader/nso.cpp

@@ -39,7 +39,7 @@ std::vector<u8> DecompressSegment(const std::vector<u8>& compressed_data,
     const std::vector<u8> uncompressed_data =
         Common::Compression::DecompressDataLZ4(compressed_data, header.size);
 
-    ASSERT_MSG(uncompressed_data.size() == static_cast<int>(header.size), "{} != {}", header.size,
+    ASSERT_MSG(uncompressed_data.size() == header.size, "{} != {}", header.size,
                uncompressed_data.size());
 
     return uncompressed_data;
@@ -152,8 +152,8 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process,
         auto& system = Core::System::GetInstance();
         const auto cheats = pm->CreateCheatList(system, nso_header.build_id);
         if (!cheats.empty()) {
-            system.RegisterCheatList(cheats, Common::HexArrayToString(nso_header.build_id),
-                                     load_base, load_base + program_image.size());
+            system.RegisterCheatList(cheats, Common::HexToString(nso_header.build_id), load_base,
+                                     load_base + program_image.size());
         }
     }
 

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,7 +12,6 @@
 #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"
@@ -101,7 +100,30 @@ bool VerifyLogin(const std::string& username, const std::string& token) {
 #endif
 }
 
-TelemetrySession::TelemetrySession() {
+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) {
     // Log one-time top-level information
     AddField(Telemetry::FieldType::None, "TelemetryId", GetTelemetryId());
 
@@ -112,26 +134,28 @@ TelemetrySession::TelemetrySession() {
     AddField(Telemetry::FieldType::Session, "Init_Time", init_time);
 
     u64 program_id{};
-    const Loader::ResultStatus res{System::GetInstance().GetAppLoader().ReadProgramId(program_id)};
+    const Loader::ResultStatus res{app_loader.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;
-        System::GetInstance().GetAppLoader().ReadTitle(name);
+        app_loader.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>(System::GetInstance().GetAppLoader().GetFileType()));
+             static_cast<u8>(app_loader.GetFileType()));
 
     // Log application information
     Telemetry::AppendBuildInfo(field_collection);
@@ -162,27 +186,6 @@ TelemetrySession::TelemetrySession() {
              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,10 +4,13 @@
 
 #pragma once
 
-#include <memory>
 #include <string>
 #include "common/telemetry.h"
 
+namespace Loader {
+class AppLoader;
+}
+
 namespace Core {
 
 /**
@@ -15,11 +18,33 @@ 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 : NonCopyable {
+class TelemetrySession {
 public:
-    TelemetrySession();
+    explicit 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,15 +6,8 @@
 
 #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,7 +6,6 @@
 #include <atomic>
 #include <cmath>
 #include <functional>
-#include <iterator>
 #include <mutex>
 #include <string>
 #include <thread>
@@ -15,7 +14,6 @@
 #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"
@@ -23,12 +21,10 @@
 #include "core/frontend/input.h"
 #include "input_common/sdl/sdl_impl.h"
 
-namespace InputCommon {
-
-namespace SDL {
+namespace InputCommon::SDL {
 
 static std::string GetGUID(SDL_Joystick* joystick) {
-    SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
+    const SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
     char guid_str[33];
     SDL_JoystickGetGUIDString(guid, guid_str, sizeof(guid_str));
     return guid_str;
@@ -37,26 +33,27 @@ 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* userdata, SDL_Event* event) {
-    SDLState* sdl_state = reinterpret_cast<SDLState*>(userdata);
+static int SDLEventWatcher(void* user_data, SDL_Event* event) {
+    auto* const sdl_state = static_cast<SDLState*>(user_data);
+
     // 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,
-                decltype(&SDL_JoystickClose) deleter = &SDL_JoystickClose)
-        : guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, deleter} {}
+    SDLJoystick(std::string guid_, int port_, SDL_Joystick* joystick)
+        : guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, &SDL_JoystickClose} {}
 
     void SetButton(int button, bool value) {
         std::lock_guard lock{mutex};
-        state.buttons[button] = value;
+        state.buttons.insert_or_assign(button, value);
     }
 
     bool GetButton(int button) const {
@@ -66,7 +63,7 @@ public:
 
     void SetAxis(int axis, Sint16 value) {
         std::lock_guard lock{mutex};
-        state.axes[axis] = value;
+        state.axes.insert_or_assign(axis, value);
     }
 
     float GetAxis(int axis) const {
@@ -93,7 +90,7 @@ public:
 
     void SetHat(int hat, Uint8 direction) {
         std::lock_guard lock{mutex};
-        state.hats[hat] = direction;
+        state.hats.insert_or_assign(hat, direction);
     }
 
     bool GetHatDirection(int hat, Uint8 direction) const {
@@ -118,10 +115,8 @@ public:
         return sdl_joystick.get();
     }
 
-    void SetSDLJoystick(SDL_Joystick* joystick,
-                        decltype(&SDL_JoystickClose) deleter = &SDL_JoystickClose) {
-        sdl_joystick =
-            std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)>(joystick, deleter);
+    void SetSDLJoystick(SDL_Joystick* joystick) {
+        sdl_joystick.reset(joystick);
     }
 
 private:
@@ -136,59 +131,57 @@ 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() <= port) {
-            auto joystick = std::make_shared<SDLJoystick>(guid, it->second.size(), nullptr,
-                                                          [](SDL_Joystick*) {});
+        while (it->second.size() <= static_cast<std::size_t>(port)) {
+            auto joystick =
+                std::make_shared<SDLJoystick>(guid, static_cast<int>(it->second.size()), nullptr);
             it->second.emplace_back(std::move(joystick));
         }
         return it->second[port];
     }
-    auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr, [](SDL_Joystick*) {});
+    auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr);
     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};
-    auto map_it = joystick_map.find(guid);
+    const auto map_it = joystick_map.find(guid);
     if (map_it != joystick_map.end()) {
-        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();
-                                   });
+        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();
+                         });
         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...
-        auto nullptr_it = std::find_if(map_it->second.begin(), map_it->second.end(),
-                                       [](const std::shared_ptr<SDLJoystick>& joystick) {
-                                           return !joystick->GetSDLJoystick();
-                                       });
+        const 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
-        auto joystick = std::make_shared<SDLJoystick>(guid, map_it->second.size(), sdl_joystick);
+        const int port = static_cast<int>(map_it->second.size());
+        auto joystick = std::make_shared<SDLJoystick>(guid, port, 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));
 }
@@ -215,17 +208,19 @@ void SDLState::InitJoystick(int joystick_index) {
         (*it)->SetSDLJoystick(sdl_joystick);
         return;
     }
-    auto joystick = std::make_shared<SDLJoystick>(guid, joystick_guid_list.size(), sdl_joystick);
+    const int port = static_cast<int>(joystick_guid_list.size());
+    auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick);
     joystick_guid_list.emplace_back(std::move(joystick));
 }
 
 void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
-    std::string guid = GetGUID(sdl_joystick);
+    const 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
-        auto& joystick_guid_list = joystick_map[guid];
+        const 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) {
@@ -233,9 +228,10 @@ void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
                          });
         joystick = *joystick_it;
     }
-    // Destruct SDL_Joystick outside the lock guard because SDL can internally call event calback
-    // which locks the mutex again
-    joystick->SetSDLJoystick(nullptr, [](SDL_Joystick*) {});
+
+    // Destruct SDL_Joystick outside the lock guard because SDL can internally call the
+    // event callback which locks the mutex again.
+    joystick->SetSDLJoystick(nullptr);
 }
 
 void SDLState::HandleGameControllerEvent(const SDL_Event& event) {
@@ -317,9 +313,10 @@ public:
           trigger_if_greater(trigger_if_greater_) {}
 
     bool GetStatus() const override {
-        float axis_value = joystick->GetAxis(axis);
-        if (trigger_if_greater)
+        const float axis_value = joystick->GetAxis(axis);
+        if (trigger_if_greater) {
             return axis_value > threshold;
+        }
         return axis_value < threshold;
     }
 
@@ -444,7 +441,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);
-        float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
+        const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
 
         auto joystick = state.GetSDLJoystickByGUID(guid, port);
 
@@ -470,7 +467,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", SDL_GetError());
+        LOG_ERROR(Input, "Failed to set hint for background events with: {}", SDL_GetError());
     }
 
     SDL_AddEventWatch(&SDLEventWatcher, this);
@@ -507,12 +504,12 @@ SDLState::~SDLState() {
     }
 }
 
-Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event) {
+static Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event) {
     Common::ParamPackage params({{"engine", "sdl"}});
 
     switch (event.type) {
     case SDL_JOYAXISMOTION: {
-        auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+        const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
         params.Set("port", joystick->GetPort());
         params.Set("guid", joystick->GetGUID());
         params.Set("axis", event.jaxis.axis);
@@ -526,14 +523,14 @@ Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Eve
         break;
     }
     case SDL_JOYBUTTONUP: {
-        auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which);
+        const 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: {
-        auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which);
+        const auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which);
         params.Set("port", joystick->GetPort());
         params.Set("guid", joystick->GetGUID());
         params.Set("hat", event.jhat.hat);
@@ -607,8 +604,8 @@ public:
         SDLPoller::Start();
 
         // Reset stored axes
-        analog_xaxis = -1;
-        analog_yaxis = -1;
+        analog_x_axis = -1;
+        analog_y_axis = -1;
         analog_axes_joystick = -1;
     }
 
@@ -620,25 +617,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.
-            int axis = event.jaxis.axis;
-            if (analog_xaxis == -1) {
-                analog_xaxis = axis;
+            const int axis = event.jaxis.axis;
+            if (analog_x_axis == -1) {
+                analog_x_axis = axis;
                 analog_axes_joystick = event.jaxis.which;
-            } else if (analog_yaxis == -1 && analog_xaxis != axis &&
+            } else if (analog_y_axis == -1 && analog_x_axis != axis &&
                        analog_axes_joystick == event.jaxis.which) {
-                analog_yaxis = axis;
+                analog_y_axis = axis;
             }
         }
         Common::ParamPackage params;
-        if (analog_xaxis != -1 && analog_yaxis != -1) {
-            auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+        if (analog_x_axis != -1 && analog_y_axis != -1) {
+            const 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_xaxis);
-            params.Set("axis_y", analog_yaxis);
-            analog_xaxis = -1;
-            analog_yaxis = -1;
+            params.Set("axis_x", analog_x_axis);
+            params.Set("axis_y", analog_y_axis);
+            analog_x_axis = -1;
+            analog_y_axis = -1;
             analog_axes_joystick = -1;
             return params;
         }
@@ -646,8 +643,8 @@ public:
     }
 
 private:
-    int analog_xaxis = -1;
-    int analog_yaxis = -1;
+    int analog_x_axis = -1;
+    int analog_y_axis = -1;
     SDL_JoystickID analog_axes_joystick = -1;
 };
 } // namespace Polling
@@ -667,5 +664,4 @@ SDLState::Pollers SDLState::GetPollers(InputCommon::Polling::DeviceType type) {
     return pollers;
 }
 
-} // namespace SDL
-} // namespace InputCommon
+} // namespace InputCommon::SDL

src/input_common/sdl/sdl_impl.h

@@ -6,7 +6,10 @@
 
 #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"
 
@@ -16,9 +19,9 @@ using SDL_JoystickID = s32;
 
 namespace InputCommon::SDL {
 
-class SDLJoystick;
-class SDLButtonFactory;
 class SDLAnalogFactory;
+class SDLButtonFactory;
+class SDLJoystick;
 
 class SDLState : public State {
 public:
@@ -31,7 +34,13 @@ 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
@@ -102,6 +100,9 @@ add_library(video_core STATIC
     shader/decode/xmad.cpp
     shader/decode/other.cpp
     shader/decode.cpp
+    shader/node_helper.cpp
+    shader/node_helper.h
+    shader/node.h
     shader/shader_ir.cpp
     shader/shader_ir.h
     shader/track.cpp

src/video_core/engines/kepler_compute.h

@@ -140,7 +140,7 @@ public:
 
         BitField<0, 16, u32> shared_alloc;
 
-        BitField<0, 31, u32> block_dim_x;
+        BitField<16, 16, u32> block_dim_x;
         union {
             BitField<0, 16, u32> block_dim_y;
             BitField<16, 16, u32> block_dim_z;
@@ -153,7 +153,7 @@ public:
 
         INSERT_PADDING_WORDS(0x8);
 
-        struct {
+        struct ConstBufferConfig {
             u32 address_low;
             union {
                 BitField<0, 8, u32> address_high;
@@ -163,7 +163,8 @@ public:
                 return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high.Value()) << 32) |
                                              address_low);
             }
-        } const_buffer_config[8];
+        };
+        std::array<ConstBufferConfig, NumConstBuffers> const_buffer_config;
 
         union {
             BitField<0, 20, u32> local_pos_alloc;

src/video_core/engines/shader_bytecode.h

@@ -1663,6 +1663,7 @@ 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"),
@@ -1686,7 +1687,6 @@ 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(9000)};
+    const s64 synchronization_ticks{Core::Timing::usToCycles(std::chrono::microseconds{9000})};
     system.CoreTiming().ScheduleEvent(synchronization_ticks, synchronization_event, fence);
 }
 

src/video_core/memory_manager.h

@@ -163,8 +163,8 @@ private:
     static constexpr u64 page_size{1 << page_bits};
     static constexpr u64 page_mask{page_size - 1};
 
-    /// Address space in bits, this is fairly arbitrary but sufficiently large.
-    static constexpr u32 address_space_width{39};
+    /// Address space in bits, according to Tegra X1 TRM
+    static constexpr u32 address_space_width{40};
     /// Start address for mapping, this is fairly arbitrary but must be non-zero.
     static constexpr GPUVAddr address_space_base{0x100000};
     /// End of address space, based on address space in bits.

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,11 +2,14 @@
 // 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 {
 
@@ -24,6 +27,7 @@ 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) {
@@ -31,10 +35,12 @@ Device::Device(std::nullptr_t) {
     max_vertex_attributes = 16;
     max_varyings = 15;
     has_variable_aoffi = true;
+    has_component_indexing_bug = false;
 }
 
 bool Device::TestVariableAoffi() {
     const GLchar* AOFFI_TEST = R"(#version 430 core
+// This is a unit test, please ignore me on apitrace bug reports.
 uniform sampler2D tex;
 uniform ivec2 variable_offset;
 void main() {
@@ -51,4 +57,53 @@ 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,13 +30,19 @@ 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
@@ -984,13 +950,21 @@ void RasterizerOpenGL::SyncPrimitiveRestart() {
 void RasterizerOpenGL::SyncDepthTestState() {
     const auto& regs = system.GPU().Maxwell3D().regs;
 
-    state.depth.test_enabled = regs.depth_test_enable != 0;
     state.depth.write_mask = regs.depth_write_enabled ? GL_TRUE : GL_FALSE;
 
-    if (!state.depth.test_enabled)
+    // Workaround OpenGL's weird design choice where depth testing needs to be enabled to be able to
+    // write to the depth buffer, regardless of glDepthMask state.
+    if (state.depth.write_mask && state.depth.test_enabled == 0) {
+        state.depth.test_enabled = true;
+        state.depth.test_func = GL_ALWAYS;
         return;
+    }
 
-    state.depth.test_func = MaxwellToGL::ComparisonOp(regs.depth_test_func);
+    // Otherwise use what the game is explicitly asking
+    state.depth.test_enabled = regs.depth_test_enable != 0;
+    if (state.depth.test_enabled) {
+        state.depth.test_func = MaxwellToGL::ComparisonOp(regs.depth_test_func);
+    }
 }
 
 void RasterizerOpenGL::SyncStencilTestState() {
@@ -1152,10 +1126,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(Maxwell::ShaderProgram program) {
-    const auto& gpu{Core::System::GetInstance().GPU().Maxwell3D()};
+GPUVAddr GetShaderAddress(Core::System& system, Maxwell::ShaderProgram program) {
+    const auto& gpu{system.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;
 }
@@ -170,7 +170,8 @@ GLShader::ProgramResult CreateProgram(const Device& device, Maxwell::ShaderProgr
 CachedProgram SpecializeShader(const std::string& code, const GLShader::ShaderEntries& entries,
                                Maxwell::ShaderProgram program_type, BaseBindings base_bindings,
                                GLenum primitive_mode, bool hint_retrievable = false) {
-    std::string source = "#version 430 core\n";
+    std::string source = "#version 430 core\n"
+                         "#extension GL_ARB_separate_shader_objects : enable\n\n";
     source += fmt::format("#define EMULATION_UBO_BINDING {}\n", base_bindings.cbuf++);
 
     for (const auto& cbuf : entries.const_buffers) {
@@ -349,7 +350,8 @@ ShaderDiskCacheUsage CachedShader::GetUsage(GLenum primitive_mode,
 
 ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer, Core::System& system,
                                      Core::Frontend::EmuWindow& emu_window, const Device& device)
-    : RasterizerCache{rasterizer}, emu_window{emu_window}, device{device}, disk_cache{system} {}
+    : RasterizerCache{rasterizer}, system{system}, emu_window{emu_window}, device{device},
+      disk_cache{system} {}
 
 void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
                                       const VideoCore::DiskResourceLoadCallback& callback) {
@@ -545,42 +547,45 @@ std::unordered_map<u64, UnspecializedShader> ShaderCacheOpenGL::GenerateUnspecia
 }
 
 Shader ShaderCacheOpenGL::GetStageProgram(Maxwell::ShaderProgram program) {
-    if (!Core::System::GetInstance().GPU().Maxwell3D().dirty_flags.shaders) {
-        return last_shaders[static_cast<u32>(program)];
+    if (!system.GPU().Maxwell3D().dirty_flags.shaders) {
+        return last_shaders[static_cast<std::size_t>(program)];
     }
 
-    auto& memory_manager{Core::System::GetInstance().GPU().MemoryManager()};
-    const GPUVAddr program_addr{GetShaderAddress(program)};
+    auto& memory_manager{system.GPU().MemoryManager()};
+    const GPUVAddr program_addr{GetShaderAddress(system, 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) {
-        // 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);
+    if (shader) {
+        return last_shaders[static_cast<std::size_t>(program)] = shader;
     }
 
-    return last_shaders[static_cast<u32>(program)] = 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;
 }
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -137,6 +137,7 @@ 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

@@ -31,6 +31,8 @@ using Tegra::Shader::IpaInterpMode;
 using Tegra::Shader::IpaMode;
 using Tegra::Shader::IpaSampleMode;
 using Tegra::Shader::Register;
+
+using namespace std::string_literals;
 using namespace VideoCommon::Shader;
 
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
@@ -43,7 +45,6 @@ struct TextureAoffi {};
 using TextureArgument = std::pair<Type, Node>;
 using TextureIR = std::variant<TextureAoffi, TextureArgument>;
 
-enum : u32 { POSITION_VARYING_LOCATION = 0, GENERIC_VARYING_START_LOCATION = 1 };
 constexpr u32 MAX_CONSTBUFFER_ELEMENTS =
     static_cast<u32>(RasterizerOpenGL::MaxConstbufferSize) / (4 * sizeof(float));
 
@@ -93,11 +94,9 @@ private:
 };
 
 /// Generates code to use for a swizzle operation.
-std::string GetSwizzle(u32 elem) {
-    ASSERT(elem <= 3);
-    std::string swizzle = ".";
-    swizzle += "xyzw"[elem];
-    return swizzle;
+constexpr const char* GetSwizzle(u32 element) {
+    constexpr std::array<const char*, 4> swizzle = {".x", ".y", ".z", ".w"};
+    return swizzle.at(element);
 }
 
 /// Translate topology
@@ -124,8 +123,8 @@ bool IsPrecise(Operation operand) {
     return false;
 }
 
-bool IsPrecise(Node node) {
-    if (const auto operation = std::get_if<OperationNode>(node)) {
+bool IsPrecise(const Node& node) {
+    if (const auto operation = std::get_if<OperationNode>(&*node)) {
         return IsPrecise(*operation);
     }
     return false;
@@ -144,6 +143,24 @@ u32 GetGenericAttributeIndex(Attribute::Index index) {
     return static_cast<u32>(index) - static_cast<u32>(Attribute::Index::Attribute_0);
 }
 
+constexpr const char* GetFlowStackPrefix(MetaStackClass stack) {
+    switch (stack) {
+    case MetaStackClass::Ssy:
+        return "ssy";
+    case MetaStackClass::Pbk:
+        return "pbk";
+    }
+    return {};
+}
+
+std::string FlowStackName(MetaStackClass stack) {
+    return fmt::format("{}_flow_stack", GetFlowStackPrefix(stack));
+}
+
+std::string FlowStackTopName(MetaStackClass stack) {
+    return fmt::format("{}_flow_stack_top", GetFlowStackPrefix(stack));
+}
+
 class GLSLDecompiler final {
 public:
     explicit GLSLDecompiler(const Device& device, const ShaderIR& ir, ShaderStage stage,
@@ -174,8 +191,10 @@ public:
         // TODO(Subv): Figure out the actual depth of the flow stack, for now it seems
         // unlikely that shaders will use 20 nested SSYs and PBKs.
         constexpr u32 FLOW_STACK_SIZE = 20;
-        code.AddLine("uint flow_stack[{}];", FLOW_STACK_SIZE);
-        code.AddLine("uint flow_stack_top = 0u;");
+        for (const auto stack : std::array{MetaStackClass::Ssy, MetaStackClass::Pbk}) {
+            code.AddLine("uint {}[{}];", FlowStackName(stack), FLOW_STACK_SIZE);
+            code.AddLine("uint {} = 0u;", FlowStackTopName(stack));
+        }
 
         code.AddLine("while (true) {{");
         ++code.scope;
@@ -247,6 +266,12 @@ private:
         code.AddLine("layout ({}, max_vertices = {}) out;", topology, max_vertices);
         code.AddNewLine();
 
+        code.AddLine("in gl_PerVertex {{");
+        ++code.scope;
+        code.AddLine("vec4 gl_Position;");
+        --code.scope;
+        code.AddLine("}} gl_in[];");
+
         DeclareVertexRedeclarations();
     }
 
@@ -349,7 +374,7 @@ private:
     }
 
     void DeclareInputAttribute(Attribute::Index index, bool skip_unused) {
-        const u32 generic_index{GetGenericAttributeIndex(index)};
+        const u32 location{GetGenericAttributeIndex(index)};
 
         std::string name{GetInputAttribute(index)};
         if (stage == ShaderStage::Geometry) {
@@ -358,19 +383,13 @@ private:
 
         std::string suffix;
         if (stage == ShaderStage::Fragment) {
-            const auto input_mode{header.ps.GetAttributeUse(generic_index)};
+            const auto input_mode{header.ps.GetAttributeUse(location)};
             if (skip_unused && input_mode == AttributeUse::Unused) {
                 return;
             }
             suffix = GetInputFlags(input_mode);
         }
 
-        u32 location = generic_index;
-        if (stage != ShaderStage::Vertex) {
-            // If inputs are varyings, add an offset
-            location += GENERIC_VARYING_START_LOCATION;
-        }
-
         code.AddLine("layout (location = {}) {} in vec4 {};", location, suffix, name);
     }
 
@@ -395,7 +414,7 @@ private:
     }
 
     void DeclareOutputAttribute(Attribute::Index index) {
-        const u32 location{GetGenericAttributeIndex(index) + GENERIC_VARYING_START_LOCATION};
+        const u32 location{GetGenericAttributeIndex(index)};
         code.AddLine("layout (location = {}) out vec4 {};", location, GetOutputAttribute(index));
     }
 
@@ -498,15 +517,15 @@ private:
     }
 
     void VisitBlock(const NodeBlock& bb) {
-        for (const Node node : bb) {
+        for (const auto& node : bb) {
             if (const std::string expr = Visit(node); !expr.empty()) {
                 code.AddLine(expr);
             }
         }
     }
 
-    std::string Visit(Node node) {
-        if (const auto operation = std::get_if<OperationNode>(node)) {
+    std::string Visit(const Node& node) {
+        if (const auto operation = std::get_if<OperationNode>(&*node)) {
             const auto operation_index = static_cast<std::size_t>(operation->GetCode());
             if (operation_index >= operation_decompilers.size()) {
                 UNREACHABLE_MSG("Out of bounds operation: {}", operation_index);
@@ -520,7 +539,7 @@ private:
             return (this->*decompiler)(*operation);
         }
 
-        if (const auto gpr = std::get_if<GprNode>(node)) {
+        if (const auto gpr = std::get_if<GprNode>(&*node)) {
             const u32 index = gpr->GetIndex();
             if (index == Register::ZeroIndex) {
                 return "0";
@@ -528,7 +547,7 @@ private:
             return GetRegister(index);
         }
 
-        if (const auto immediate = std::get_if<ImmediateNode>(node)) {
+        if (const auto immediate = std::get_if<ImmediateNode>(&*node)) {
             const u32 value = immediate->GetValue();
             if (value < 10) {
                 // For eyecandy avoid using hex numbers on single digits
@@ -537,7 +556,7 @@ private:
             return fmt::format("utof(0x{:x}u)", immediate->GetValue());
         }
 
-        if (const auto predicate = std::get_if<PredicateNode>(node)) {
+        if (const auto predicate = std::get_if<PredicateNode>(&*node)) {
             const auto value = [&]() -> std::string {
                 switch (const auto index = predicate->GetIndex(); index) {
                 case Tegra::Shader::Pred::UnusedIndex:
@@ -554,7 +573,7 @@ private:
             return value;
         }
 
-        if (const auto abuf = std::get_if<AbufNode>(node)) {
+        if (const auto abuf = std::get_if<AbufNode>(&*node)) {
             UNIMPLEMENTED_IF_MSG(abuf->IsPhysicalBuffer() && stage == ShaderStage::Geometry,
                                  "Physical attributes in geometry shaders are not implemented");
             if (abuf->IsPhysicalBuffer()) {
@@ -564,9 +583,9 @@ private:
             return ReadAttribute(abuf->GetIndex(), abuf->GetElement(), abuf->GetBuffer());
         }
 
-        if (const auto cbuf = std::get_if<CbufNode>(node)) {
+        if (const auto cbuf = std::get_if<CbufNode>(&*node)) {
             const Node offset = cbuf->GetOffset();
-            if (const auto immediate = std::get_if<ImmediateNode>(offset)) {
+            if (const auto immediate = std::get_if<ImmediateNode>(&*offset)) {
                 // Direct access
                 const u32 offset_imm = immediate->GetValue();
                 ASSERT_MSG(offset_imm % 4 == 0, "Unaligned cbuf direct access");
@@ -577,30 +596,47 @@ private:
             if (std::holds_alternative<OperationNode>(*offset)) {
                 // Indirect access
                 const std::string final_offset = code.GenerateTemporary();
-                code.AddLine("uint {} = (ftou({}) / 4);", final_offset, Visit(offset));
-                return fmt::format("{}[{} / 4][{} % 4]", GetConstBuffer(cbuf->GetIndex()),
-                                   final_offset, final_offset);
+                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;
             }
 
             UNREACHABLE_MSG("Unmanaged offset node type");
         }
 
-        if (const auto gmem = std::get_if<GmemNode>(node)) {
+        if (const auto gmem = std::get_if<GmemNode>(&*node)) {
             const std::string real = Visit(gmem->GetRealAddress());
             const std::string base = Visit(gmem->GetBaseAddress());
             const std::string final_offset = fmt::format("(ftou({}) - ftou({})) / 4", real, base);
             return fmt::format("{}[{}]", GetGlobalMemory(gmem->GetDescriptor()), final_offset);
         }
 
-        if (const auto lmem = std::get_if<LmemNode>(node)) {
+        if (const auto lmem = std::get_if<LmemNode>(&*node)) {
             return fmt::format("{}[ftou({}) / 4]", GetLocalMemory(), Visit(lmem->GetAddress()));
         }
 
-        if (const auto internal_flag = std::get_if<InternalFlagNode>(node)) {
+        if (const auto internal_flag = std::get_if<InternalFlagNode>(&*node)) {
             return GetInternalFlag(internal_flag->GetFlag());
         }
 
-        if (const auto conditional = std::get_if<ConditionalNode>(node)) {
+        if (const auto conditional = std::get_if<ConditionalNode>(&*node)) {
             // It's invalid to call conditional on nested nodes, use an operation instead
             code.AddLine("if ({}) {{", Visit(conditional->GetCondition()));
             ++code.scope;
@@ -612,7 +648,7 @@ private:
             return {};
         }
 
-        if (const auto comment = std::get_if<CommentNode>(node)) {
+        if (const auto comment = std::get_if<CommentNode>(&*node)) {
             return "// " + comment->GetText();
         }
 
@@ -620,7 +656,7 @@ private:
         return {};
     }
 
-    std::string ReadAttribute(Attribute::Index attribute, u32 element, Node buffer = {}) {
+    std::string ReadAttribute(Attribute::Index attribute, u32 element, const Node& buffer = {}) {
         const auto GeometryPass = [&](std::string_view name) {
             if (stage == ShaderStage::Geometry && buffer) {
                 // TODO(Rodrigo): Guard geometry inputs against out of bound reads. Some games
@@ -633,10 +669,14 @@ private:
 
         switch (attribute) {
         case Attribute::Index::Position:
-            if (stage != ShaderStage::Fragment) {
-                return GeometryPass("position") + GetSwizzle(element);
-            } else {
-                return element == 3 ? "1.0f" : "gl_FragCoord" + GetSwizzle(element);
+            switch (stage) {
+            case ShaderStage::Geometry:
+                return fmt::format("gl_in[ftou({})].gl_Position{}", Visit(buffer),
+                                   GetSwizzle(element));
+            case ShaderStage::Fragment:
+                return element == 3 ? "1.0f" : ("gl_FragCoord"s + GetSwizzle(element));
+            default:
+                UNREACHABLE();
             }
         case Attribute::Index::PointCoord:
             switch (element) {
@@ -852,7 +892,7 @@ private:
         std::string expr = ", ";
         switch (type) {
         case Type::Int:
-            if (const auto immediate = std::get_if<ImmediateNode>(operand)) {
+            if (const auto immediate = std::get_if<ImmediateNode>(&*operand)) {
                 // Inline the string as an immediate integer in GLSL (some extra arguments are
                 // required to be constant)
                 expr += std::to_string(static_cast<s32>(immediate->GetValue()));
@@ -884,7 +924,7 @@ private:
 
         for (std::size_t index = 0; index < aoffi.size(); ++index) {
             const auto operand{aoffi.at(index)};
-            if (const auto immediate = std::get_if<ImmediateNode>(operand)) {
+            if (const auto immediate = std::get_if<ImmediateNode>(&*operand)) {
                 // Inline the string as an immediate integer in GLSL (AOFFI arguments are required
                 // to be constant by the standard).
                 expr += std::to_string(static_cast<s32>(immediate->GetValue()));
@@ -905,23 +945,23 @@ private:
     }
 
     std::string Assign(Operation operation) {
-        const Node dest = operation[0];
-        const Node src = operation[1];
+        const Node& dest = operation[0];
+        const Node& src = operation[1];
 
         std::string target;
-        if (const auto gpr = std::get_if<GprNode>(dest)) {
+        if (const auto gpr = std::get_if<GprNode>(&*dest)) {
             if (gpr->GetIndex() == Register::ZeroIndex) {
                 // Writing to Register::ZeroIndex is a no op
                 return {};
             }
             target = GetRegister(gpr->GetIndex());
-        } else if (const auto abuf = std::get_if<AbufNode>(dest)) {
+        } else if (const auto abuf = std::get_if<AbufNode>(&*dest)) {
             UNIMPLEMENTED_IF(abuf->IsPhysicalBuffer());
 
             target = [&]() -> std::string {
                 switch (const auto attribute = abuf->GetIndex(); abuf->GetIndex()) {
                 case Attribute::Index::Position:
-                    return "position" + GetSwizzle(abuf->GetElement());
+                    return "gl_Position"s + GetSwizzle(abuf->GetElement());
                 case Attribute::Index::PointSize:
                     return "gl_PointSize";
                 case Attribute::Index::ClipDistances0123:
@@ -937,9 +977,9 @@ private:
                     return "0";
                 }
             }();
-        } else if (const auto lmem = std::get_if<LmemNode>(dest)) {
+        } else if (const auto lmem = std::get_if<LmemNode>(&*dest)) {
             target = fmt::format("{}[ftou({}) / 4]", GetLocalMemory(), Visit(lmem->GetAddress()));
-        } else if (const auto gmem = std::get_if<GmemNode>(dest)) {
+        } else if (const auto gmem = std::get_if<GmemNode>(&*dest)) {
             const std::string real = Visit(gmem->GetRealAddress());
             const std::string base = Visit(gmem->GetBaseAddress());
             const std::string final_offset = fmt::format("(ftou({}) - ftou({})) / 4", real, base);
@@ -1216,12 +1256,12 @@ private:
     }
 
     std::string LogicalAssign(Operation operation) {
-        const Node dest = operation[0];
-        const Node src = operation[1];
+        const Node& dest = operation[0];
+        const Node& src = operation[1];
 
         std::string target;
 
-        if (const auto pred = std::get_if<PredicateNode>(dest)) {
+        if (const auto pred = std::get_if<PredicateNode>(&*dest)) {
             ASSERT_MSG(!pred->IsNegated(), "Negating logical assignment");
 
             const auto index = pred->GetIndex();
@@ -1232,7 +1272,7 @@ private:
                 return {};
             }
             target = GetPredicate(index);
-        } else if (const auto flag = std::get_if<InternalFlagNode>(dest)) {
+        } else if (const auto flag = std::get_if<InternalFlagNode>(&*dest)) {
             target = GetInternalFlag(flag->GetFlag());
         }
 
@@ -1409,7 +1449,7 @@ private:
     }
 
     std::string Branch(Operation operation) {
-        const auto target = std::get_if<ImmediateNode>(operation[0]);
+        const auto target = std::get_if<ImmediateNode>(&*operation[0]);
         UNIMPLEMENTED_IF(!target);
 
         code.AddLine("jmp_to = 0x{:x}u;", target->GetValue());
@@ -1418,15 +1458,18 @@ private:
     }
 
     std::string PushFlowStack(Operation operation) {
-        const auto target = std::get_if<ImmediateNode>(operation[0]);
+        const auto stack = std::get<MetaStackClass>(operation.GetMeta());
+        const auto target = std::get_if<ImmediateNode>(&*operation[0]);
         UNIMPLEMENTED_IF(!target);
 
-        code.AddLine("flow_stack[flow_stack_top++] = 0x{:x}u;", target->GetValue());
+        code.AddLine("{}[{}++] = 0x{:x}u;", FlowStackName(stack), FlowStackTopName(stack),
+                     target->GetValue());
         return {};
     }
 
     std::string PopFlowStack(Operation operation) {
-        code.AddLine("jmp_to = flow_stack[--flow_stack_top];");
+        const auto stack = std::get<MetaStackClass>(operation.GetMeta());
+        code.AddLine("jmp_to = {}[--{}];", FlowStackName(stack), FlowStackTopName(stack));
         code.AddLine("break;");
         return {};
     }
@@ -1447,27 +1490,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) {
@@ -1506,9 +1531,7 @@ private:
 
         // If a geometry shader is attached, it will always flip (it's the last stage before
         // fragment). For more info about flipping, refer to gl_shader_gen.cpp.
-        code.AddLine("position.xy *= viewport_flip.xy;");
-        code.AddLine("gl_Position = position;");
-        code.AddLine("position.w = 1.0;");
+        code.AddLine("gl_Position.xy *= viewport_flip.xy;");
         code.AddLine("EmitVertex();");
         return {};
     }
@@ -1526,6 +1549,16 @@ private:
         return "uintBitsToFloat(config_pack[2])";
     }
 
+    template <u32 element>
+    std::string LocalInvocationId(Operation) {
+        return "utof(gl_LocalInvocationID"s + GetSwizzle(element) + ')';
+    }
+
+    template <u32 element>
+    std::string WorkGroupId(Operation) {
+        return "utof(gl_WorkGroupID"s + GetSwizzle(element) + ')';
+    }
+
     static constexpr OperationDecompilersArray operation_decompilers = {
         &GLSLDecompiler::Assign,
 
@@ -1665,6 +1698,12 @@ private:
         &GLSLDecompiler::EndPrimitive,
 
         &GLSLDecompiler::YNegate,
+        &GLSLDecompiler::LocalInvocationId<0>,
+        &GLSLDecompiler::LocalInvocationId<1>,
+        &GLSLDecompiler::LocalInvocationId<2>,
+        &GLSLDecompiler::WorkGroupId<0>,
+        &GLSLDecompiler::WorkGroupId<1>,
+        &GLSLDecompiler::WorkGroupId<2>,
     };
 
     std::string GetRegister(u32 index) const {
@@ -1730,8 +1769,7 @@ private:
     }
 
     u32 GetNumPhysicalVaryings() const {
-        return std::min<u32>(device.GetMaxVaryings() - GENERIC_VARYING_START_LOCATION,
-                             Maxwell::NumVaryings);
+        return std::min<u32>(device.GetMaxVaryings(), Maxwell::NumVaryings);
     }
 
     const Device& device;

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -19,17 +19,13 @@ static constexpr u32 PROGRAM_OFFSET{10};
 ProgramResult GenerateVertexShader(const Device& device, const ShaderSetup& setup) {
     const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);
 
-    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
-    out += "// Shader Unique Id: VS" + id + "\n\n";
+    std::string out = "// Shader Unique Id: VS" + id + "\n\n";
     out += GetCommonDeclarations();
 
     out += R"(
-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;
 };
 
 )";
@@ -49,7 +45,6 @@ layout (std140, binding = EMULATION_UBO_BINDING) uniform vs_config {
 
     out += R"(
 void main() {
-    position = vec4(0.0, 0.0, 0.0, 0.0);
     execute_vertex();
 )";
 
@@ -60,19 +55,12 @@ void main() {
     out += R"(
 
     // Set Position Y direction
-    position.y *= utof(config_pack[2]);
+    gl_Position.y *= utof(config_pack[2]);
     // Check if the flip stage is VertexB
     // Config pack's second value is flip_stage
     if (config_pack[1] == 1) {
         // Viewport can be flipped, which is unsupported by glViewport
-        position.xy *= viewport_flip.xy;
-    }
-    gl_Position = position;
-
-    // TODO(bunnei): This is likely a hack, position.w should be interpolated as 1.0
-    // For now, this is here to bring order in lieu of proper emulation
-    if (config_pack[1] == 1) {
-        position.w = 1.0;
+        gl_Position.xy *= viewport_flip.xy;
     }
 })";
 
@@ -82,18 +70,13 @@ void main() {
 ProgramResult GenerateGeometryShader(const Device& device, const ShaderSetup& setup) {
     const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);
 
-    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
-    out += "// Shader Unique Id: GS" + id + "\n\n";
+    std::string out = "// Shader Unique Id: GS" + id + "\n\n";
     out += GetCommonDeclarations();
 
     out += R"(
-layout (location = 0) in vec4 gs_position[];
-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;
 };
 
 )";
@@ -113,8 +96,7 @@ void main() {
 ProgramResult GenerateFragmentShader(const Device& device, const ShaderSetup& setup) {
     const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);
 
-    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
-    out += "// Shader Unique Id: FS" + id + "\n\n";
+    std::string out = "// Shader Unique Id: FS" + id + "\n\n";
     out += GetCommonDeclarations();
 
     out += R"(
@@ -127,38 +109,11 @@ layout (location = 5) out vec4 FragColor5;
 layout (location = 6) out vec4 FragColor6;
 layout (location = 7) out vec4 FragColor7;
 
-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/renderer_vulkan/vk_device.cpp

@@ -18,6 +18,7 @@ constexpr std::array<vk::Format, 3> Depth24UnormS8Uint = {
     vk::Format::eD32SfloatS8Uint, vk::Format::eD16UnormS8Uint, {}};
 constexpr std::array<vk::Format, 3> Depth16UnormS8Uint = {
     vk::Format::eD24UnormS8Uint, vk::Format::eD32SfloatS8Uint, {}};
+constexpr std::array<vk::Format, 2> Astc = {vk::Format::eA8B8G8R8UnormPack32, {}};
 
 } // namespace Alternatives
 
@@ -51,15 +52,19 @@ VKDevice::VKDevice(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice phy
     : physical{physical}, format_properties{GetFormatProperties(dldi, physical)} {
     SetupFamilies(dldi, surface);
     SetupProperties(dldi);
+    SetupFeatures(dldi);
 }
 
 VKDevice::~VKDevice() = default;
 
 bool VKDevice::Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instance) {
-    const auto queue_cis = GetDeviceQueueCreateInfos();
-    vk::PhysicalDeviceFeatures device_features{};
+    vk::PhysicalDeviceFeatures device_features;
+    device_features.vertexPipelineStoresAndAtomics = true;
+    device_features.independentBlend = true;
+    device_features.textureCompressionASTC_LDR = is_optimal_astc_supported;
 
-    const std::vector<const char*> extensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
+    const auto queue_cis = GetDeviceQueueCreateInfos();
+    const std::vector<const char*> extensions = LoadExtensions(dldi);
     const vk::DeviceCreateInfo device_ci({}, static_cast<u32>(queue_cis.size()), queue_cis.data(),
                                          0, nullptr, static_cast<u32>(extensions.size()),
                                          extensions.data(), &device_features);
@@ -90,7 +95,7 @@ vk::Format VKDevice::GetSupportedFormat(vk::Format wanted_format,
         LOG_CRITICAL(Render_Vulkan,
                      "Format={} with usage={} and type={} has no defined alternatives and host "
                      "hardware does not support it",
-                     static_cast<u32>(wanted_format), static_cast<u32>(wanted_usage),
+                     vk::to_string(wanted_format), vk::to_string(wanted_usage),
                      static_cast<u32>(format_type));
         UNREACHABLE();
         return wanted_format;
@@ -118,6 +123,30 @@ vk::Format VKDevice::GetSupportedFormat(vk::Format wanted_format,
     return wanted_format;
 }
 
+bool VKDevice::IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features,
+                                      const vk::DispatchLoaderDynamic& dldi) const {
+    if (!features.textureCompressionASTC_LDR) {
+        return false;
+    }
+    const auto format_feature_usage{
+        vk::FormatFeatureFlagBits::eSampledImage | vk::FormatFeatureFlagBits::eBlitSrc |
+        vk::FormatFeatureFlagBits::eBlitDst | vk::FormatFeatureFlagBits::eTransferSrc |
+        vk::FormatFeatureFlagBits::eTransferDst};
+    constexpr std::array<vk::Format, 9> astc_formats = {
+        vk::Format::eAstc4x4UnormBlock, vk::Format::eAstc4x4SrgbBlock,
+        vk::Format::eAstc8x8SrgbBlock,  vk::Format::eAstc8x6SrgbBlock,
+        vk::Format::eAstc5x4SrgbBlock,  vk::Format::eAstc5x5UnormBlock,
+        vk::Format::eAstc5x5SrgbBlock,  vk::Format::eAstc10x8UnormBlock,
+        vk::Format::eAstc10x8SrgbBlock};
+    for (const auto format : astc_formats) {
+        const auto format_properties{physical.getFormatProperties(format, dldi)};
+        if (!(format_properties.optimalTilingFeatures & format_feature_usage)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 bool VKDevice::IsFormatSupported(vk::Format wanted_format, vk::FormatFeatureFlags wanted_usage,
                                  FormatType format_type) const {
     const auto it = format_properties.find(wanted_format);
@@ -132,11 +161,9 @@ bool VKDevice::IsFormatSupported(vk::Format wanted_format, vk::FormatFeatureFlag
 
 bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical,
                           vk::SurfaceKHR surface) {
-    const std::string swapchain_extension = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
-
     bool has_swapchain{};
     for (const auto& prop : physical.enumerateDeviceExtensionProperties(nullptr, dldi)) {
-        has_swapchain |= prop.extensionName == swapchain_extension;
+        has_swapchain |= prop.extensionName == std::string(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
     }
     if (!has_swapchain) {
         // The device doesn't support creating swapchains.
@@ -160,8 +187,14 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
     }
 
     // TODO(Rodrigo): Check if the device matches all requeriments.
-    const vk::PhysicalDeviceProperties props = physical.getProperties(dldi);
-    if (props.limits.maxUniformBufferRange < 65536) {
+    const auto properties{physical.getProperties(dldi)};
+    const auto limits{properties.limits};
+    if (limits.maxUniformBufferRange < 65536) {
+        return false;
+    }
+
+    const vk::PhysicalDeviceFeatures features{physical.getFeatures(dldi)};
+    if (!features.vertexPipelineStoresAndAtomics || !features.independentBlend) {
         return false;
     }
 
@@ -169,6 +202,30 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
     return true;
 }
 
+std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynamic& dldi) {
+    std::vector<const char*> extensions;
+    extensions.reserve(2);
+    extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+    const auto Test = [&](const vk::ExtensionProperties& extension,
+                          std::optional<std::reference_wrapper<bool>> status, const char* name,
+                          u32 revision) {
+        if (extension.extensionName != std::string(name)) {
+            return;
+        }
+        extensions.push_back(name);
+        if (status) {
+            status->get() = true;
+        }
+    };
+
+    for (const auto& extension : physical.enumerateDeviceExtensionProperties(nullptr, dldi)) {
+        Test(extension, ext_scalar_block_layout, VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, 1);
+    }
+
+    return extensions;
+}
+
 void VKDevice::SetupFamilies(const vk::DispatchLoaderDynamic& dldi, vk::SurfaceKHR surface) {
     std::optional<u32> graphics_family_, present_family_;
 
@@ -196,10 +253,16 @@ void VKDevice::SetupProperties(const vk::DispatchLoaderDynamic& dldi) {
     const vk::PhysicalDeviceProperties props = physical.getProperties(dldi);
     device_type = props.deviceType;
     uniform_buffer_alignment = static_cast<u64>(props.limits.minUniformBufferOffsetAlignment);
+    max_storage_buffer_range = static_cast<u64>(props.limits.maxStorageBufferRange);
+}
+
+void VKDevice::SetupFeatures(const vk::DispatchLoaderDynamic& dldi) {
+    const auto supported_features{physical.getFeatures(dldi)};
+    is_optimal_astc_supported = IsOptimalAstcSupported(supported_features, dldi);
 }
 
 std::vector<vk::DeviceQueueCreateInfo> VKDevice::GetDeviceQueueCreateInfos() const {
-    static const float QUEUE_PRIORITY = 1.f;
+    static const float QUEUE_PRIORITY = 1.0f;
 
     std::set<u32> unique_queue_families = {graphics_family, present_family};
     std::vector<vk::DeviceQueueCreateInfo> queue_cis;
@@ -212,26 +275,43 @@ std::vector<vk::DeviceQueueCreateInfo> VKDevice::GetDeviceQueueCreateInfos() con
 
 std::map<vk::Format, vk::FormatProperties> VKDevice::GetFormatProperties(
     const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical) {
+    static constexpr std::array formats{vk::Format::eA8B8G8R8UnormPack32,
+                                        vk::Format::eB5G6R5UnormPack16,
+                                        vk::Format::eA2B10G10R10UnormPack32,
+                                        vk::Format::eR32G32B32A32Sfloat,
+                                        vk::Format::eR16G16Unorm,
+                                        vk::Format::eR16G16Snorm,
+                                        vk::Format::eR8G8B8A8Srgb,
+                                        vk::Format::eR8Unorm,
+                                        vk::Format::eB10G11R11UfloatPack32,
+                                        vk::Format::eR32Sfloat,
+                                        vk::Format::eR16Sfloat,
+                                        vk::Format::eR16G16B16A16Sfloat,
+                                        vk::Format::eD32Sfloat,
+                                        vk::Format::eD16Unorm,
+                                        vk::Format::eD16UnormS8Uint,
+                                        vk::Format::eD24UnormS8Uint,
+                                        vk::Format::eD32SfloatS8Uint,
+                                        vk::Format::eBc1RgbaUnormBlock,
+                                        vk::Format::eBc2UnormBlock,
+                                        vk::Format::eBc3UnormBlock,
+                                        vk::Format::eBc4UnormBlock,
+                                        vk::Format::eBc5UnormBlock,
+                                        vk::Format::eBc5SnormBlock,
+                                        vk::Format::eBc7UnormBlock,
+                                        vk::Format::eAstc4x4UnormBlock,
+                                        vk::Format::eAstc4x4SrgbBlock,
+                                        vk::Format::eAstc8x8SrgbBlock,
+                                        vk::Format::eAstc8x6SrgbBlock,
+                                        vk::Format::eAstc5x4SrgbBlock,
+                                        vk::Format::eAstc5x5UnormBlock,
+                                        vk::Format::eAstc5x5SrgbBlock,
+                                        vk::Format::eAstc10x8UnormBlock,
+                                        vk::Format::eAstc10x8SrgbBlock};
     std::map<vk::Format, vk::FormatProperties> format_properties;
-
-    const auto AddFormatQuery = [&format_properties, &dldi, physical](vk::Format format) {
+    for (const auto format : formats) {
         format_properties.emplace(format, physical.getFormatProperties(format, dldi));
-    };
-    AddFormatQuery(vk::Format::eA8B8G8R8UnormPack32);
-    AddFormatQuery(vk::Format::eB5G6R5UnormPack16);
-    AddFormatQuery(vk::Format::eA2B10G10R10UnormPack32);
-    AddFormatQuery(vk::Format::eR8G8B8A8Srgb);
-    AddFormatQuery(vk::Format::eR8Unorm);
-    AddFormatQuery(vk::Format::eD32Sfloat);
-    AddFormatQuery(vk::Format::eD16Unorm);
-    AddFormatQuery(vk::Format::eD16UnormS8Uint);
-    AddFormatQuery(vk::Format::eD24UnormS8Uint);
-    AddFormatQuery(vk::Format::eD32SfloatS8Uint);
-    AddFormatQuery(vk::Format::eBc1RgbaUnormBlock);
-    AddFormatQuery(vk::Format::eBc2UnormBlock);
-    AddFormatQuery(vk::Format::eBc3UnormBlock);
-    AddFormatQuery(vk::Format::eBc4UnormBlock);
-
+    }
     return format_properties;
 }
 

src/video_core/renderer_vulkan/vk_device.h

@@ -11,7 +11,7 @@
 
 namespace Vulkan {
 
-/// Format usage descriptor
+/// Format usage descriptor.
 enum class FormatType { Linear, Optimal, Buffer };
 
 /// Handles data specific to a physical device.
@@ -34,12 +34,12 @@ public:
     vk::Format GetSupportedFormat(vk::Format wanted_format, vk::FormatFeatureFlags wanted_usage,
                                   FormatType format_type) const;
 
-    /// Returns the dispatch loader with direct function pointers of the device
+    /// Returns the dispatch loader with direct function pointers of the device.
     const vk::DispatchLoaderDynamic& GetDispatchLoader() const {
         return dld;
     }
 
-    /// Returns the logical device
+    /// Returns the logical device.
     vk::Device GetLogical() const {
         return logical.get();
     }
@@ -69,30 +69,55 @@ public:
         return present_family;
     }
 
-    /// Returns if the device is integrated with the host CPU
+    /// Returns if the device is integrated with the host CPU.
     bool IsIntegrated() const {
         return device_type == vk::PhysicalDeviceType::eIntegratedGpu;
     }
 
-    /// Returns uniform buffer alignment requeriment
+    /// Returns uniform buffer alignment requeriment.
     u64 GetUniformBufferAlignment() const {
         return uniform_buffer_alignment;
     }
 
+    /// Returns the maximum range for storage buffers.
+    u64 GetMaxStorageBufferRange() const {
+        return max_storage_buffer_range;
+    }
+
+    /// Returns true if ASTC is natively supported.
+    bool IsOptimalAstcSupported() const {
+        return is_optimal_astc_supported;
+    }
+
+    /// Returns true if the device supports VK_EXT_scalar_block_layout.
+    bool IsExtScalarBlockLayoutSupported() const {
+        return ext_scalar_block_layout;
+    }
+
     /// Checks if the physical device is suitable.
     static bool IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical,
                            vk::SurfaceKHR surface);
 
 private:
+    /// Loads extensions into a vector and stores available ones in this object.
+    std::vector<const char*> LoadExtensions(const vk::DispatchLoaderDynamic& dldi);
+
     /// Sets up queue families.
     void SetupFamilies(const vk::DispatchLoaderDynamic& dldi, vk::SurfaceKHR surface);
 
     /// Sets up device properties.
     void SetupProperties(const vk::DispatchLoaderDynamic& dldi);
 
+    /// Sets up device features.
+    void SetupFeatures(const vk::DispatchLoaderDynamic& dldi);
+
     /// Returns a list of queue initialization descriptors.
     std::vector<vk::DeviceQueueCreateInfo> GetDeviceQueueCreateInfos() const;
 
+    /// Returns true if ASTC textures are natively supported.
+    bool IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features,
+                                const vk::DispatchLoaderDynamic& dldi) const;
+
     /// Returns true if a format is supported.
     bool IsFormatSupported(vk::Format wanted_format, vk::FormatFeatureFlags wanted_usage,
                            FormatType format_type) const;
@@ -101,16 +126,19 @@ private:
     static std::map<vk::Format, vk::FormatProperties> GetFormatProperties(
         const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical);
 
-    const vk::PhysicalDevice physical;  ///< Physical device
-    vk::DispatchLoaderDynamic dld;      ///< Device function pointers
-    UniqueDevice logical;               ///< Logical device
-    vk::Queue graphics_queue;           ///< Main graphics queue
-    vk::Queue present_queue;            ///< Main present queue
-    u32 graphics_family{};              ///< Main graphics queue family index
-    u32 present_family{};               ///< Main present queue family index
-    vk::PhysicalDeviceType device_type; ///< Physical device type
-    u64 uniform_buffer_alignment{};     ///< Uniform buffer alignment requeriment
-    std::map<vk::Format, vk::FormatProperties> format_properties; ///< Format properties dictionary
+    const vk::PhysicalDevice physical;  ///< Physical device.
+    vk::DispatchLoaderDynamic dld;      ///< Device function pointers.
+    UniqueDevice logical;               ///< Logical device.
+    vk::Queue graphics_queue;           ///< Main graphics queue.
+    vk::Queue present_queue;            ///< Main present queue.
+    u32 graphics_family{};              ///< Main graphics queue family index.
+    u32 present_family{};               ///< Main present queue family index.
+    vk::PhysicalDeviceType device_type; ///< Physical device type.
+    u64 uniform_buffer_alignment{};     ///< Uniform buffer alignment requeriment.
+    u64 max_storage_buffer_range{};     ///< Max storage buffer size.
+    bool is_optimal_astc_supported{};   ///< Support for native ASTC.
+    bool ext_scalar_block_layout{};     ///< Support for VK_EXT_scalar_block_layout.
+    std::map<vk::Format, vk::FormatProperties> format_properties; ///< Format properties dictionary.
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_shader_decompiler.cpp

@@ -17,6 +17,7 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/shader_bytecode.h"
 #include "video_core/engines/shader_header.h"
+#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_shader_decompiler.h"
 #include "video_core/shader/shader_ir.h"
 
@@ -33,7 +34,8 @@ using ShaderStage = Tegra::Engines::Maxwell3D::Regs::ShaderStage;
 using Operation = const OperationNode&;
 
 // TODO(Rodrigo): Use rasterizer's value
-constexpr u32 MAX_CONSTBUFFER_ELEMENTS = 0x1000;
+constexpr u32 MAX_CONSTBUFFER_FLOATS = 0x4000;
+constexpr u32 MAX_CONSTBUFFER_ELEMENTS = MAX_CONSTBUFFER_FLOATS / 4;
 constexpr u32 STAGE_BINDING_STRIDE = 0x100;
 
 enum class Type { Bool, Bool2, Float, Int, Uint, HalfFloat };
@@ -87,8 +89,8 @@ bool IsPrecise(Operation operand) {
 
 class SPIRVDecompiler : public Sirit::Module {
 public:
-    explicit SPIRVDecompiler(const ShaderIR& ir, ShaderStage stage)
-        : Module(0x00010300), ir{ir}, stage{stage}, header{ir.GetHeader()} {
+    explicit SPIRVDecompiler(const VKDevice& device, const ShaderIR& ir, ShaderStage stage)
+        : Module(0x00010300), device{device}, ir{ir}, stage{stage}, header{ir.GetHeader()} {
         AddCapability(spv::Capability::Shader);
         AddExtension("SPV_KHR_storage_buffer_storage_class");
         AddExtension("SPV_KHR_variable_pointers");
@@ -130,20 +132,16 @@ public:
             branch_labels.push_back(label);
         }
 
-        // TODO(Rodrigo): Figure out the actual depth of the flow stack, for now it seems unlikely
-        // that shaders will use 20 nested SSYs and PBKs.
-        constexpr u32 FLOW_STACK_SIZE = 20;
-        const Id flow_stack_type = TypeArray(t_uint, Constant(t_uint, FLOW_STACK_SIZE));
         jmp_to = Emit(OpVariable(TypePointer(spv::StorageClass::Function, t_uint),
                                  spv::StorageClass::Function, Constant(t_uint, first_address)));
-        flow_stack = Emit(OpVariable(TypePointer(spv::StorageClass::Function, flow_stack_type),
-                                     spv::StorageClass::Function, ConstantNull(flow_stack_type)));
-        flow_stack_top =
-            Emit(OpVariable(t_func_uint, spv::StorageClass::Function, Constant(t_uint, 0)));
+        std::tie(ssy_flow_stack, ssy_flow_stack_top) = CreateFlowStack();
+        std::tie(pbk_flow_stack, pbk_flow_stack_top) = CreateFlowStack();
 
         Name(jmp_to, "jmp_to");
-        Name(flow_stack, "flow_stack");
-        Name(flow_stack_top, "flow_stack_top");
+        Name(ssy_flow_stack, "ssy_flow_stack");
+        Name(ssy_flow_stack_top, "ssy_flow_stack_top");
+        Name(pbk_flow_stack, "pbk_flow_stack");
+        Name(pbk_flow_stack_top, "pbk_flow_stack_top");
 
         Emit(OpBranch(loop_label));
         Emit(loop_label);
@@ -195,7 +193,9 @@ public:
             entries.samplers.emplace_back(sampler);
         }
         for (const auto& attribute : ir.GetInputAttributes()) {
-            entries.attributes.insert(GetGenericAttributeLocation(attribute));
+            if (IsGenericAttribute(attribute)) {
+                entries.attributes.insert(GetGenericAttributeLocation(attribute));
+            }
         }
         entries.clip_distances = ir.GetClipDistances();
         entries.shader_length = ir.GetLength();
@@ -210,7 +210,6 @@ private:
         std::array<OperationDecompilerFn, static_cast<std::size_t>(OperationCode::Amount)>;
 
     static constexpr auto INTERNAL_FLAGS_COUNT = static_cast<std::size_t>(InternalFlag::Amount);
-    static constexpr u32 CBUF_STRIDE = 16;
 
     void AllocateBindings() {
         const u32 binding_base = static_cast<u32>(stage) * STAGE_BINDING_STRIDE;
@@ -315,6 +314,7 @@ private:
         constexpr std::array<const char*, INTERNAL_FLAGS_COUNT> names = {"zero", "sign", "carry",
                                                                          "overflow"};
         for (std::size_t flag = 0; flag < INTERNAL_FLAGS_COUNT; ++flag) {
+            const auto flag_code = static_cast<InternalFlag>(flag);
             const Id id = OpVariable(t_prv_bool, spv::StorageClass::Private, v_false);
             internal_flags[flag] = AddGlobalVariable(Name(id, names[flag]));
         }
@@ -374,7 +374,9 @@ private:
         u32 binding = const_buffers_base_binding;
         for (const auto& entry : ir.GetConstantBuffers()) {
             const auto [index, size] = entry;
-            const Id id = OpVariable(t_cbuf_ubo, spv::StorageClass::Uniform);
+            const Id type =
+                device.IsExtScalarBlockLayoutSupported() ? t_cbuf_scalar_ubo : t_cbuf_std140_ubo;
+            const Id id = OpVariable(type, spv::StorageClass::Uniform);
             AddGlobalVariable(Name(id, fmt::format("cbuf_{}", index)));
 
             Decorate(id, spv::Decoration::Binding, binding++);
@@ -475,13 +477,13 @@ private:
     }
 
     void VisitBasicBlock(const NodeBlock& bb) {
-        for (const Node node : bb) {
+        for (const auto& node : bb) {
             static_cast<void>(Visit(node));
         }
     }
 
-    Id Visit(Node node) {
-        if (const auto operation = std::get_if<OperationNode>(node)) {
+    Id Visit(const Node& node) {
+        if (const auto operation = std::get_if<OperationNode>(&*node)) {
             const auto operation_index = static_cast<std::size_t>(operation->GetCode());
             const auto decompiler = operation_decompilers[operation_index];
             if (decompiler == nullptr) {
@@ -489,17 +491,17 @@ private:
             }
             return (this->*decompiler)(*operation);
 
-        } else if (const auto gpr = std::get_if<GprNode>(node)) {
+        } else if (const auto gpr = std::get_if<GprNode>(&*node)) {
             const u32 index = gpr->GetIndex();
             if (index == Register::ZeroIndex) {
                 return Constant(t_float, 0.0f);
             }
             return Emit(OpLoad(t_float, registers.at(index)));
 
-        } else if (const auto immediate = std::get_if<ImmediateNode>(node)) {
+        } else if (const auto immediate = std::get_if<ImmediateNode>(&*node)) {
             return BitcastTo<Type::Float>(Constant(t_uint, immediate->GetValue()));
 
-        } else if (const auto predicate = std::get_if<PredicateNode>(node)) {
+        } else if (const auto predicate = std::get_if<PredicateNode>(&*node)) {
             const auto value = [&]() -> Id {
                 switch (const auto index = predicate->GetIndex(); index) {
                 case Tegra::Shader::Pred::UnusedIndex:
@@ -515,7 +517,7 @@ private:
             }
             return value;
 
-        } else if (const auto abuf = std::get_if<AbufNode>(node)) {
+        } else if (const auto abuf = std::get_if<AbufNode>(&*node)) {
             const auto attribute = abuf->GetIndex();
             const auto element = abuf->GetElement();
 
@@ -565,40 +567,42 @@ private:
             }
             UNIMPLEMENTED_MSG("Unhandled input attribute: {}", static_cast<u32>(attribute));
 
-        } else if (const auto cbuf = std::get_if<CbufNode>(node)) {
-            const Node offset = cbuf->GetOffset();
+        } else if (const auto cbuf = std::get_if<CbufNode>(&*node)) {
+            const Node& offset = cbuf->GetOffset();
             const Id buffer_id = constant_buffers.at(cbuf->GetIndex());
 
-            Id buffer_index{};
-            Id buffer_element{};
-
-            if (const auto immediate = std::get_if<ImmediateNode>(offset)) {
-                // Direct access
-                const u32 offset_imm = immediate->GetValue();
-                ASSERT(offset_imm % 4 == 0);
-                buffer_index = Constant(t_uint, offset_imm / 16);
-                buffer_element = Constant(t_uint, (offset_imm / 4) % 4);
-
-            } else if (std::holds_alternative<OperationNode>(*offset)) {
-                // Indirect access
-                // TODO(Rodrigo): Use a uniform buffer stride of 4 and drop this slow math (which
-                // emits sub-optimal code on GLSL from my testing).
-                const Id offset_id = BitcastTo<Type::Uint>(Visit(offset));
-                const Id unsafe_offset = Emit(OpUDiv(t_uint, offset_id, Constant(t_uint, 4)));
-                const Id final_offset = Emit(
-                    OpUMod(t_uint, unsafe_offset, Constant(t_uint, MAX_CONSTBUFFER_ELEMENTS - 1)));
-                buffer_index = Emit(OpUDiv(t_uint, final_offset, Constant(t_uint, 4)));
-                buffer_element = Emit(OpUMod(t_uint, final_offset, Constant(t_uint, 4)));
-
+            Id pointer{};
+            if (device.IsExtScalarBlockLayoutSupported()) {
+                const Id buffer_offset = Emit(OpShiftRightLogical(
+                    t_uint, BitcastTo<Type::Uint>(Visit(offset)), Constant(t_uint, 2u)));
+                pointer = Emit(
+                    OpAccessChain(t_cbuf_float, buffer_id, Constant(t_uint, 0u), buffer_offset));
             } else {
-                UNREACHABLE_MSG("Unmanaged offset node type");
+                Id buffer_index{};
+                Id buffer_element{};
+                if (const auto immediate = std::get_if<ImmediateNode>(&*offset)) {
+                    // Direct access
+                    const u32 offset_imm = immediate->GetValue();
+                    ASSERT(offset_imm % 4 == 0);
+                    buffer_index = Constant(t_uint, offset_imm / 16);
+                    buffer_element = Constant(t_uint, (offset_imm / 4) % 4);
+                } else if (std::holds_alternative<OperationNode>(*offset)) {
+                    // Indirect access
+                    const Id offset_id = BitcastTo<Type::Uint>(Visit(offset));
+                    const Id unsafe_offset = Emit(OpUDiv(t_uint, offset_id, Constant(t_uint, 4)));
+                    const Id final_offset = Emit(OpUMod(
+                        t_uint, unsafe_offset, Constant(t_uint, MAX_CONSTBUFFER_ELEMENTS - 1)));
+                    buffer_index = Emit(OpUDiv(t_uint, final_offset, Constant(t_uint, 4)));
+                    buffer_element = Emit(OpUMod(t_uint, final_offset, Constant(t_uint, 4)));
+                } else {
+                    UNREACHABLE_MSG("Unmanaged offset node type");
+                }
+                pointer = Emit(OpAccessChain(t_cbuf_float, buffer_id, Constant(t_uint, 0),
+                                             buffer_index, buffer_element));
             }
-
-            const Id pointer = Emit(OpAccessChain(t_cbuf_float, buffer_id, Constant(t_uint, 0),
-                                                  buffer_index, buffer_element));
             return Emit(OpLoad(t_float, pointer));
 
-        } else if (const auto gmem = std::get_if<GmemNode>(node)) {
+        } else if (const auto gmem = std::get_if<GmemNode>(&*node)) {
             const Id gmem_buffer = global_buffers.at(gmem->GetDescriptor());
             const Id real = BitcastTo<Type::Uint>(Visit(gmem->GetRealAddress()));
             const Id base = BitcastTo<Type::Uint>(Visit(gmem->GetBaseAddress()));
@@ -608,11 +612,13 @@ private:
             return Emit(OpLoad(t_float, Emit(OpAccessChain(t_gmem_float, gmem_buffer,
                                                            Constant(t_uint, 0u), offset))));
 
-        } else if (const auto conditional = std::get_if<ConditionalNode>(node)) {
+        } else if (const auto conditional = std::get_if<ConditionalNode>(&*node)) {
             // It's invalid to call conditional on nested nodes, use an operation instead
             const Id true_label = OpLabel();
             const Id skip_label = OpLabel();
-            Emit(OpBranchConditional(Visit(conditional->GetCondition()), true_label, skip_label));
+            const Id condition = Visit(conditional->GetCondition());
+            Emit(OpSelectionMerge(skip_label, spv::SelectionControlMask::MaskNone));
+            Emit(OpBranchConditional(condition, true_label, skip_label));
             Emit(true_label);
 
             VisitBasicBlock(conditional->GetCode());
@@ -621,7 +627,7 @@ private:
             Emit(skip_label);
             return {};
 
-        } else if (const auto comment = std::get_if<CommentNode>(node)) {
+        } else if (const auto comment = std::get_if<CommentNode>(&*node)) {
             Name(Emit(OpUndef(t_void)), comment->GetText());
             return {};
         }
@@ -689,18 +695,18 @@ private:
     }
 
     Id Assign(Operation operation) {
-        const Node dest = operation[0];
-        const Node src = operation[1];
+        const Node& dest = operation[0];
+        const Node& src = operation[1];
 
         Id target{};
-        if (const auto gpr = std::get_if<GprNode>(dest)) {
+        if (const auto gpr = std::get_if<GprNode>(&*dest)) {
             if (gpr->GetIndex() == Register::ZeroIndex) {
                 // Writing to Register::ZeroIndex is a no op
                 return {};
             }
             target = registers.at(gpr->GetIndex());
 
-        } else if (const auto abuf = std::get_if<AbufNode>(dest)) {
+        } else if (const auto abuf = std::get_if<AbufNode>(&*dest)) {
             target = [&]() -> Id {
                 switch (const auto attribute = abuf->GetIndex(); attribute) {
                 case Attribute::Index::Position:
@@ -725,7 +731,7 @@ private:
                 }
             }();
 
-        } else if (const auto lmem = std::get_if<LmemNode>(dest)) {
+        } else if (const auto lmem = std::get_if<LmemNode>(&*dest)) {
             Id address = BitcastTo<Type::Uint>(Visit(lmem->GetAddress()));
             address = Emit(OpUDiv(t_uint, address, Constant(t_uint, 4)));
             target = Emit(OpAccessChain(t_prv_float, local_memory, {address}));
@@ -771,11 +777,11 @@ private:
     }
 
     Id LogicalAssign(Operation operation) {
-        const Node dest = operation[0];
-        const Node src = operation[1];
+        const Node& dest = operation[0];
+        const Node& src = operation[1];
 
         Id target{};
-        if (const auto pred = std::get_if<PredicateNode>(dest)) {
+        if (const auto pred = std::get_if<PredicateNode>(&*dest)) {
             ASSERT_MSG(!pred->IsNegated(), "Negating logical assignment");
 
             const auto index = pred->GetIndex();
@@ -787,7 +793,7 @@ private:
             }
             target = predicates.at(index);
 
-        } else if (const auto flag = std::get_if<InternalFlagNode>(dest)) {
+        } else if (const auto flag = std::get_if<InternalFlagNode>(&*dest)) {
             target = internal_flags.at(static_cast<u32>(flag->GetFlag()));
         }
 
@@ -873,7 +879,7 @@ private:
         } else {
             u32 component_value = 0;
             if (meta->component) {
-                const auto component = std::get_if<ImmediateNode>(meta->component);
+                const auto component = std::get_if<ImmediateNode>(&*meta->component);
                 ASSERT_MSG(component, "Component is not an immediate value");
                 component_value = component->GetValue();
             }
@@ -930,7 +936,7 @@ private:
     }
 
     Id Branch(Operation operation) {
-        const auto target = std::get_if<ImmediateNode>(operation[0]);
+        const auto target = std::get_if<ImmediateNode>(&*operation[0]);
         UNIMPLEMENTED_IF(!target);
 
         Emit(OpStore(jmp_to, Constant(t_uint, target->GetValue())));
@@ -939,9 +945,10 @@ private:
     }
 
     Id PushFlowStack(Operation operation) {
-        const auto target = std::get_if<ImmediateNode>(operation[0]);
+        const auto target = std::get_if<ImmediateNode>(&*operation[0]);
         ASSERT(target);
 
+        const auto [flow_stack, flow_stack_top] = GetFlowStack(operation);
         const Id current = Emit(OpLoad(t_uint, flow_stack_top));
         const Id next = Emit(OpIAdd(t_uint, current, Constant(t_uint, 1)));
         const Id access = Emit(OpAccessChain(t_func_uint, flow_stack, current));
@@ -952,6 +959,7 @@ private:
     }
 
     Id PopFlowStack(Operation operation) {
+        const auto [flow_stack, flow_stack_top] = GetFlowStack(operation);
         const Id current = Emit(OpLoad(t_uint, flow_stack_top));
         const Id previous = Emit(OpISub(t_uint, current, Constant(t_uint, 1)));
         const Id access = Emit(OpAccessChain(t_func_uint, flow_stack, previous));
@@ -968,11 +976,11 @@ private:
         case ShaderStage::Vertex: {
             // TODO(Rodrigo): We should use VK_EXT_depth_range_unrestricted instead, but it doesn't
             // seem to be working on Nvidia's drivers and Intel (mesa and blob) doesn't support it.
-            const Id position = AccessElement(t_float4, per_vertex, position_index);
-            Id depth = Emit(OpLoad(t_float, AccessElement(t_out_float, position, 2)));
+            const Id z_pointer = AccessElement(t_out_float, per_vertex, position_index, 2u);
+            Id depth = Emit(OpLoad(t_float, z_pointer));
             depth = Emit(OpFAdd(t_float, depth, Constant(t_float, 1.0f)));
             depth = Emit(OpFMul(t_float, depth, Constant(t_float, 0.5f)));
-            Emit(OpStore(AccessElement(t_out_float, position, 2), depth));
+            Emit(OpStore(z_pointer, depth));
             break;
         }
         case ShaderStage::Fragment: {
@@ -1035,6 +1043,18 @@ private:
         return {};
     }
 
+    template <u32 element>
+    Id LocalInvocationId(Operation) {
+        UNIMPLEMENTED();
+        return {};
+    }
+
+    template <u32 element>
+    Id WorkGroupId(Operation) {
+        UNIMPLEMENTED();
+        return {};
+    }
+
     Id DeclareBuiltIn(spv::BuiltIn builtin, spv::StorageClass storage, Id type,
                       const std::string& name) {
         const Id id = OpVariable(type, storage);
@@ -1150,6 +1170,31 @@ private:
         Emit(skip_label);
     }
 
+    std::tuple<Id, Id> CreateFlowStack() {
+        // TODO(Rodrigo): Figure out the actual depth of the flow stack, for now it seems unlikely
+        // that shaders will use 20 nested SSYs and PBKs.
+        constexpr u32 FLOW_STACK_SIZE = 20;
+        constexpr auto storage_class = spv::StorageClass::Function;
+
+        const Id flow_stack_type = TypeArray(t_uint, Constant(t_uint, FLOW_STACK_SIZE));
+        const Id stack = Emit(OpVariable(TypePointer(storage_class, flow_stack_type), storage_class,
+                                         ConstantNull(flow_stack_type)));
+        const Id top = Emit(OpVariable(t_func_uint, storage_class, Constant(t_uint, 0)));
+        return std::tie(stack, top);
+    }
+
+    std::pair<Id, Id> GetFlowStack(Operation operation) {
+        const auto stack_class = std::get<MetaStackClass>(operation.GetMeta());
+        switch (stack_class) {
+        case MetaStackClass::Ssy:
+            return {ssy_flow_stack, ssy_flow_stack_top};
+        case MetaStackClass::Pbk:
+            return {pbk_flow_stack, pbk_flow_stack_top};
+        }
+        UNREACHABLE();
+        return {};
+    }
+
     static constexpr OperationDecompilersArray operation_decompilers = {
         &SPIRVDecompiler::Assign,
 
@@ -1291,8 +1336,15 @@ private:
         &SPIRVDecompiler::EndPrimitive,
 
         &SPIRVDecompiler::YNegate,
+        &SPIRVDecompiler::LocalInvocationId<0>,
+        &SPIRVDecompiler::LocalInvocationId<1>,
+        &SPIRVDecompiler::LocalInvocationId<2>,
+        &SPIRVDecompiler::WorkGroupId<0>,
+        &SPIRVDecompiler::WorkGroupId<1>,
+        &SPIRVDecompiler::WorkGroupId<2>,
     };
 
+    const VKDevice& device;
     const ShaderIR& ir;
     const ShaderStage stage;
     const Tegra::Shader::Header header;
@@ -1331,12 +1383,18 @@ private:
     const Id t_out_float4 = Name(TypePointer(spv::StorageClass::Output, t_float4), "out_float4");
 
     const Id t_cbuf_float = TypePointer(spv::StorageClass::Uniform, t_float);
-    const Id t_cbuf_array =
-        Decorate(Name(TypeArray(t_float4, Constant(t_uint, MAX_CONSTBUFFER_ELEMENTS)), "CbufArray"),
-                 spv::Decoration::ArrayStride, CBUF_STRIDE);
-    const Id t_cbuf_struct = MemberDecorate(
-        Decorate(TypeStruct(t_cbuf_array), spv::Decoration::Block), 0, spv::Decoration::Offset, 0);
-    const Id t_cbuf_ubo = TypePointer(spv::StorageClass::Uniform, t_cbuf_struct);
+    const Id t_cbuf_std140 = Decorate(
+        Name(TypeArray(t_float4, Constant(t_uint, MAX_CONSTBUFFER_ELEMENTS)), "CbufStd140Array"),
+        spv::Decoration::ArrayStride, 16u);
+    const Id t_cbuf_scalar = Decorate(
+        Name(TypeArray(t_float, Constant(t_uint, MAX_CONSTBUFFER_FLOATS)), "CbufScalarArray"),
+        spv::Decoration::ArrayStride, 4u);
+    const Id t_cbuf_std140_struct = MemberDecorate(
+        Decorate(TypeStruct(t_cbuf_std140), spv::Decoration::Block), 0, spv::Decoration::Offset, 0);
+    const Id t_cbuf_scalar_struct = MemberDecorate(
+        Decorate(TypeStruct(t_cbuf_scalar), spv::Decoration::Block), 0, spv::Decoration::Offset, 0);
+    const Id t_cbuf_std140_ubo = TypePointer(spv::StorageClass::Uniform, t_cbuf_std140_struct);
+    const Id t_cbuf_scalar_ubo = TypePointer(spv::StorageClass::Uniform, t_cbuf_scalar_struct);
 
     const Id t_gmem_float = TypePointer(spv::StorageClass::StorageBuffer, t_float);
     const Id t_gmem_array =
@@ -1379,14 +1437,17 @@ private:
 
     Id execute_function{};
     Id jmp_to{};
-    Id flow_stack_top{};
-    Id flow_stack{};
+    Id ssy_flow_stack_top{};
+    Id pbk_flow_stack_top{};
+    Id ssy_flow_stack{};
+    Id pbk_flow_stack{};
     Id continue_label{};
     std::map<u32, Id> labels;
 };
 
-DecompilerResult Decompile(const VideoCommon::Shader::ShaderIR& ir, Maxwell::ShaderStage stage) {
-    auto decompiler = std::make_unique<SPIRVDecompiler>(ir, stage);
+DecompilerResult Decompile(const VKDevice& device, const VideoCommon::Shader::ShaderIR& ir,
+                           Maxwell::ShaderStage stage) {
+    auto decompiler = std::make_unique<SPIRVDecompiler>(device, ir, stage);
     decompiler->Decompile();
     return {std::move(decompiler), decompiler->GetShaderEntries()};
 }

src/video_core/renderer_vulkan/vk_shader_decompiler.h

@@ -20,10 +20,13 @@ namespace VideoCommon::Shader {
 class ShaderIR;
 }
 
+namespace Vulkan {
+class VKDevice;
+}
+
 namespace Vulkan::VKShader {
 
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
-
 using SamplerEntry = VideoCommon::Shader::Sampler;
 
 constexpr u32 DESCRIPTOR_SET = 0;
@@ -75,6 +78,7 @@ struct ShaderEntries {
 
 using DecompilerResult = std::pair<std::unique_ptr<Sirit::Module>, ShaderEntries>;
 
-DecompilerResult Decompile(const VideoCommon::Shader::ShaderIR& ir, Maxwell::ShaderStage stage);
+DecompilerResult Decompile(const VKDevice& device, const VideoCommon::Shader::ShaderIR& ir,
+                           Maxwell::ShaderStage stage);
 
 } // namespace Vulkan::VKShader

src/video_core/shader/decode.cpp

@@ -11,6 +11,7 @@
 #include "common/common_types.h"
 #include "video_core/engines/shader_bytecode.h"
 #include "video_core/engines/shader_header.h"
+#include "video_core/shader/node_helper.h"
 #include "video_core/shader/shader_ir.h"
 
 namespace VideoCommon::Shader {

src/video_core/shader/decode/arithmetic.cpp

@@ -6,6 +6,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "video_core/engines/shader_bytecode.h"
+#include "video_core/shader/node_helper.h"
 #include "video_core/shader/shader_ir.h"
 
 namespace VideoCommon::Shader {

src/video_core/shader/decode/arithmetic_half.cpp

@@ -6,6 +6,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "video_core/engines/shader_bytecode.h"
+#include "video_core/shader/node_helper.h"
 #include "video_core/shader/shader_ir.h"
 
 namespace VideoCommon::Shader {

src/video_core/shader/decode/arithmetic_half_immediate.cpp

@@ -6,6 +6,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "video_core/engines/shader_bytecode.h"
+#include "video_core/shader/node_helper.h"
 #include "video_core/shader/shader_ir.h"
 
 namespace VideoCommon::Shader {