common: Add BitArray template class

ISSUE_TEMPLATE: changes to make it more expressive and prevent low-quality issues

.github/ISSUE_TEMPLATE.md

@@ -1,16 +1,27 @@
 <!--
 Please keep in mind yuzu is EXPERIMENTAL SOFTWARE.
 
-Please read the FAQ: https://yuzu-emu.org/wiki/faq/
+Please read the FAQ:
+https://yuzu-emu.org/wiki/faq/
 
-When submitting an issue, please do the following:
+THIS IS NOT A SUPPORT FORUM, FOR SUPPORT GO TO:
+https://community.citra-emu.org/
 
-- Provide the version (commit hash) of yuzu you are using.
-- Provide sufficient detail for the issue to be reproduced.
-- Provide:
+If the FAQ does not answer your question, please go to:
+https://community.citra-emu.org/
+
+When submitting an issue, please check the following:
+
+- You have read the above.
+- You have provided the version (commit hash) of yuzu you are using.
+- You have provided sufficient detail for the issue to be reproduced.
+- You have provided system specs (if relevant).
+- Please also provide:
+  - For any issues, a log file
   - For crashes, a backtrace.
   - For graphical issues, comparison screenshots with real hardware.
   - For emulation inaccuracies, a test-case (if able).
+
 -->
 
 

.travis/linux/docker.sh

@@ -1,12 +1,12 @@
 #!/bin/bash -ex
 
 apt-get update
-apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev wget cmake ninja-build ccache
+apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev qtwebengine5-dev wget cmake ninja-build ccache
 
 cd /yuzu
 
 mkdir build && cd build
-cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -G Ninja
+cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -G Ninja
 ninja
 
 ccache -s

.travis/macos/build.sh

@@ -9,7 +9,7 @@ export PATH="/usr/local/opt/ccache/libexec:$PATH"
 
 mkdir build && cd build
 cmake --version
-cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
+cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
 make -j4
 
 ccache -s

CMakeLists.txt

@@ -19,6 +19,8 @@ option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
 option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
+option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
+
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
@@ -302,7 +304,7 @@ endif()
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
         if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
-            set(QT_VER qt-5.10.0-msvc2015_64)
+            set(QT_VER qt-5.12.0-msvc2017_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
         endif()
@@ -319,6 +321,10 @@ if (ENABLE_QT)
     endif()
 
     find_package(Qt5 REQUIRED COMPONENTS Widgets OpenGL ${QT_PREFIX_HINT})
+
+    if (YUZU_USE_QT_WEB_ENGINE)
+        find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets ${QT_PREFIX_HINT})
+    endif ()
 endif()
 
 # Platform-specific library requirements

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -5,6 +5,7 @@ function(copy_yuzu_Qt5_deps target_dir)
     set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
     set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
     set(Qt5_IMAGEFORMATS_DIR "${Qt5_DIR}/../../../plugins/imageformats/")
+    set(Qt5_RESOURCES_DIR "${Qt5_DIR}/../../../resources/")
     set(PLATFORMS ${DLL_DEST}platforms/)
     set(STYLES ${DLL_DEST}styles/)
     set(IMAGEFORMATS ${DLL_DEST}imageformats/)
@@ -17,7 +18,35 @@ function(copy_yuzu_Qt5_deps target_dir)
         Qt5OpenGL$<$<CONFIG:Debug>:d>.*
         Qt5Widgets$<$<CONFIG:Debug>:d>.*
     )
+
+    if (YUZU_USE_QT_WEB_ENGINE)
+        windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST} 
+            Qt5Network$<$<CONFIG:Debug>:d>.*
+            Qt5Positioning$<$<CONFIG:Debug>:d>.*
+            Qt5PrintSupport$<$<CONFIG:Debug>:d>.*
+            Qt5Qml$<$<CONFIG:Debug>:d>.*
+            Qt5Quick$<$<CONFIG:Debug>:d>.*
+            Qt5QuickWidgets$<$<CONFIG:Debug>:d>.*
+            Qt5WebChannel$<$<CONFIG:Debug>:d>.*
+            Qt5WebEngine$<$<CONFIG:Debug>:d>.*
+            Qt5WebEngineCore$<$<CONFIG:Debug>:d>.*
+            Qt5WebEngineWidgets$<$<CONFIG:Debug>:d>.*
+            QtWebEngineProcess$<$<CONFIG:Debug>:d>.*
+        )
+
+        windows_copy_files(${target_dir} ${Qt5_RESOURCES_DIR} ${DLL_DEST}
+            qtwebengine_resources.pak
+            qtwebengine_devtools_resources.pak
+            qtwebengine_resources_100p.pak
+            qtwebengine_resources_200p.pak
+            icudtl.dat
+        )
+    endif ()
+
     windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
     windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
-    windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS} qjpeg$<$<CONFIG:Debug>:d>.*)
+    windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS}
+        qjpeg$<$<CONFIG:Debug>:d>.*
+        qgif$<$<CONFIG:Debug>:d>.*
+        )
 endfunction(copy_yuzu_Qt5_deps)

CONTRIBUTING.md

@@ -1,136 +1 @@
-# Reporting Issues
-
-**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our [Discord server](https://discordapp.com/invite/u77vRWY), [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
-
-If you believe you have a valid issue report, please post text or a screenshot from the log (the console window that opens alongside yuzu) and build version (hex string visible in the titlebar and zip filename), as well as your hardware and software information if applicable.
-
-# Contributing
-yuzu is a brand new project, so we have a great opportunity to keep things clean and well organized early on. As such, coding style is very important when making commits. We run clang-format on our CI to check the code. Please use it to format your code when contributing. However, it doesn't cover all the rules below. Some of them aren't very strict rules since we want to be flexible and we understand that under certain circumstances some of them can be counterproductive. Just try to follow as many of them as possible.
-
-# Using clang format (version 6.0)
-When generating the native build script for your toolset, cmake will try to find the correct version of clang format (or will download it on windows). Before running cmake, please install clang format version 6.0 for your platform as follows:
-
-* Windows: do nothing; cmake will download a pre built binary for MSVC and MINGW. MSVC users can additionally install a clang format Visual Studio extension to add features like format on save.
-* OSX: run `brew install clang-format`.
-* Linux: use your package manager to get an appropriate binary.
-
-If clang format is found, then cmake will add a custom build target that can be run at any time to run clang format against *all* source files and update the formatting in them. This should be used before making a pull request so that the reviewers can spend more time reviewing the code instead of having to worry about minor style violations. On MSVC, you can run clang format by building the clang-format project in the solution. On OSX, you can either use the Makefile target `make clang-format` or by building the clang-format target in XCode. For Makefile builds, you can use the clang-format target with `make clang-format`
-
-### General Rules
-* A lot of code was taken from other projects (e.g. Citra, Dolphin, PPSSPP, Gekko). In general, when editing other people's code, follow the style of the module you're in (or better yet, fix the style if it drastically differs from our guide).
-* Line width is typically 100 characters. Please do not use 80-characters.
-* Don't ever introduce new external dependencies into Core
-* Don't use any platform specific code in Core
-* Use namespaces often
-* Avoid the use of C-style casts and instead prefer C++-style `static_cast` and `reinterpret_cast`. Try to avoid using `dynamic_cast`. Never use `const_cast`.
-
-### Naming Rules
-* Functions: `PascalCase`
-* Variables: `lower_case_underscored`. Prefix with `g_` if global.
-* Classes: `PascalCase`
-* Files and Directories: `lower_case_underscored`
-* Namespaces: `PascalCase`, `_` may also be used for clarity (e.g. `ARM_InitCore`)
-
-### Indentation/Whitespace Style
-Follow the indentation/whitespace style shown below. Do not use tabs, use 4-spaces instead.
-
-### Comments
-* For regular comments, use C++ style (`//`) comments, even for multi-line ones.
-* For doc-comments (Doxygen comments), use `/// ` if it's a single line, else use the `/**` `*/` style featured in the example. Start the text on the second line, not the first containing `/**`.
-* For items that are both defined and declared in two separate files, put the doc-comment only next to the associated declaration. (In a header file, usually.) Otherwise, put it next to the implementation. Never duplicate doc-comments in both places.
-
-```cpp
-// Includes should be sorted lexicographically
-// STD includes first
-#include <map>
-#include <memory>
-
-// then, library includes
-#include <nihstro/shared_binary.h>
-
-// finally, yuzu includes
-#include "common/math_util.h"
-#include "common/vector_math.h"
-
-// each major module is separated
-#include "video_core/pica.h"
-#include "video_core/video_core.h"
-
-namespace Example {
-
-// Namespace contents are not indented
-
-// Declare globals at the top
-int g_foo{}; // {} can be used to initialize types as 0, false, or nullptr
-char* g_some_pointer{}; // Pointer * and reference & stick to the type name, and make sure to initialize as nullptr!
-
-/// A colorful enum.
-enum SomeEnum {
-    ColorRed,   ///< The color of fire.
-    ColorGreen, ///< The color of grass.
-    ColorBlue,  ///< Not actually the color of water.
-};
-
-/**
- * Very important struct that does a lot of stuff.
- * Note that the asterisks are indented by one space to align to the first line.
- */
-struct Position {
-    int x{}, y{}; // Always intitialize member variables!
-};
-
-// Use "typename" rather than "class" here
-template <typename T>
-void FooBar() {
-    const std::string some_string{ "prefer uniform initialization" };
-
-    int some_array[]{
-        5,
-        25,
-        7,
-        42,
-    };
-
-    if (note == the_space_after_the_if) {
-        CallAfunction();
-    } else {
-        // Use a space after the // when commenting
-    }
-
-    // Place a single space after the for loop semicolons, prefer pre-increment
-    for (int i{}; i != 25; ++i) {
-        // This is how we write loops
-    }
-
-    DoStuff(this, function, call, takes, up, multiple,
-            lines, like, this);
-
-    if (this || condition_takes_up_multiple &&
-        lines && like && this || everything ||
-        alright || then) {
-
-        // Leave a blank space before the if block body if the condition was continued across
-        // several lines.
-    }
-
-    switch (var) {
-    // No indentation for case label
-    case 1: {
-        int case_var{ var + 3 };
-        DoSomething(case_var);
-        break;
-    }
-    case 3:
-        DoSomething(var);
-        return;
-
-    default:
-        // Yes, even break for the last case
-        break;
-    }
-
-    std::vector<T> you_can_declare, a_few, variables, like_this;
-}
-
-}
-```
+**The Contributor's Guide has moved to [the Citra wiki](https://github.com/citra-emu/citra/wiki/Contributing).**

appveyor.yml

@@ -42,7 +42,7 @@ before_build:
         $COMPAT = if ($env:ENABLE_COMPATIBILITY_REPORTING -eq $null) {0} else {$env:ENABLE_COMPATIBILITY_REPORTING}
         if ($env:BUILD_TYPE -eq 'msvc') {
           # redirect stderr and change the exit code to prevent powershell from cancelling the build if cmake prints a warning
-          cmd /C 'cmake -G "Visual Studio 15 2017 Win64" -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON .. 2>&1 && exit 0'
+          cmd /C 'cmake -G "Visual Studio 15 2017 Win64" -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON .. 2>&1 && exit 0'
         } else {
           C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -DYUZU_BUILD_UNICORN=1 -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON .. 2>&1"
         }
@@ -94,6 +94,7 @@ after_build:
           Copy-Item "$BUILD_DIR\*" -Destination $RELEASE_DIST -Recurse
           rm "$RELEASE_DIST\*.exe"
           Get-ChildItem "$BUILD_DIR" -Recurse -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
+          Get-ChildItem "$BUILD_DIR" -Recurse -Filter "QtWebEngineProcess*.exe" | Copy-Item -destination $RELEASE_DIST
           Copy-Item .\license.txt -Destination $RELEASE_DIST
           Copy-Item .\README.md -Destination $RELEASE_DIST
           7z a -tzip $MSVC_BUILD_ZIP $RELEASE_DIST\*

src/audio_core/time_stretch.cpp

@@ -53,8 +53,8 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
     const double lpf_gain = 1.0 - std::exp(-time_delta / lpf_time_scale);
     m_stretch_ratio += lpf_gain * (current_ratio - m_stretch_ratio);
 
-    // Place a lower limit of 5% speed.  When a game boots up, there will be
-    // many silence samples.  These do not need to be timestretched.
+    // Place a lower limit of 5% speed. When a game boots up, there will be
+    // many silence samples. These do not need to be timestretched.
     m_stretch_ratio = std::max(m_stretch_ratio, 0.05);
     m_sound_touch.setTempo(m_stretch_ratio);
 

src/common/CMakeLists.txt

@@ -43,6 +43,7 @@ add_library(common STATIC
     assert.h
     detached_tasks.cpp
     detached_tasks.h
+    bit_array.h
     bit_field.h
     bit_util.h
     cityhash.cpp

src/common/bit_array.h

@@ -0,0 +1,116 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <climits>
+#include <cstddef>
+#include <initializer_list>
+#include <limits>
+#include <type_traits>
+
+#include "common/alignment.h"
+#include "common/assert.h"
+
+namespace Common {
+
+/// Abstracts bits packed in an integer (or array of integers)
+template <typename T, std::size_t total_bits = sizeof(T) * CHAR_BIT>
+class BitArray {
+public:
+    BitArray() = default;
+
+    /// Initializes a bit array
+    constexpr BitArray(std::initializer_list<bool> list) {
+        std::size_t i = 0;
+        for (const bool element : list) {
+            TurnBit(i++, element);
+        }
+    }
+
+    /// Initializes a bit array setting all bits on or off depending on the argument
+    constexpr explicit BitArray(bool defaults) {
+        if (defaults) {
+            TurnOnAll();
+        }
+    }
+
+    /// Gets a bit value
+    constexpr bool operator[](std::size_t index) const {
+        return ((GetTypeValue(index) >> GetSubOffset(index)) & 1) != 0;
+    }
+
+    /// Gets a bit value testing for out of bound reads
+    bool at(std::size_t index) const {
+        ASSERT(index < size());
+        return operator[](index);
+    }
+
+    /// Turn on a bit
+    void TurnOn(std::size_t index) {
+        GetTypeValue(index) |= 1 << GetSubOffset(index);
+    }
+
+    /// Turn off a bit
+    void TurnOff(std::size_t index) {
+        GetTypeValue(index) &= ~static_cast<T>(1 << GetSubOffset(index));
+    }
+
+    /// Set a bit value
+    void TurnBit(std::size_t index, bool value) {
+        if (value) {
+            TurnOn(index);
+        } else {
+            TurnOff(index);
+        }
+    }
+
+    /// Turns on all bits
+    void TurnOnAll() {
+        std::memset(raw.data(), std::numeric_limits<u8>::max(), sizeof(raw));
+    }
+
+    /// Turns off all bits
+    void TurnOffAll() {
+        std::memset(raw.data(), 0, sizeof(raw));
+    }
+
+    /// Returns the size in bits of the array
+    constexpr std::size_t size() const {
+        return total_bits;
+    }
+
+    /// Returns the capacity in bits of the array
+    constexpr std::size_t capacity() const {
+        return capacity_bits;
+    }
+
+private:
+    static constexpr std::size_t type_bits = sizeof(T) * CHAR_BIT;
+    static constexpr std::size_t capacity_bits = AlignUp(total_bits, type_bits);
+
+    static constexpr std::size_t GetSubIndex(std::size_t index) {
+        return index / type_bits;
+    }
+
+    static constexpr std::size_t GetSubOffset(std::size_t index) {
+        return index % type_bits;
+    }
+
+    constexpr T GetTypeValue(std::size_t index) const {
+        return raw[GetSubIndex(index)];
+    }
+
+    T& GetTypeValue(std::size_t index) {
+        return raw[GetSubIndex(index)];
+    }
+
+    // Raw values of the array
+    std::array<T, capacity_bits / type_bits> raw{};
+
+    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+};
+
+} // namespace Common

src/core/CMakeLists.txt

@@ -88,6 +88,8 @@ add_library(core STATIC
     frontend/applets/profile_select.h
     frontend/applets/software_keyboard.cpp
     frontend/applets/software_keyboard.h
+    frontend/applets/web_browser.cpp
+    frontend/applets/web_browser.h
     frontend/emu_window.cpp
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
@@ -173,6 +175,8 @@ add_library(core STATIC
     hle/service/am/applets/software_keyboard.h
     hle/service/am/applets/stub_applet.cpp
     hle/service/am/applets/stub_applet.h
+    hle/service/am/applets/web_browser.cpp
+    hle/service/am/applets/web_browser.h
     hle/service/am/idle.cpp
     hle/service/am/idle.h
     hle/service/am/omm.cpp

src/core/core.cpp

@@ -30,8 +30,11 @@
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/perf_stats.h"
+#include "core/settings.h"
 #include "core/telemetry_session.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/gpu.h"
 #include "video_core/renderer_base.h"
@@ -94,6 +97,11 @@ struct System::Impl {
         CoreTiming::Init();
         kernel.Initialize();
 
+        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
+            std::chrono::system_clock::now().time_since_epoch());
+        Settings::values.custom_rtc_differential =
+            Settings::values.custom_rtc.value_or(current_time) - current_time;
+
         // Create a default fs if one doesn't already exist.
         if (virtual_filesystem == nullptr)
             virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
@@ -103,6 +111,8 @@ struct System::Impl {
             profile_selector = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
         if (software_keyboard == nullptr)
             software_keyboard = std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
+        if (web_browser == nullptr)
+            web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
 
         auto main_process = Kernel::Process::Create(kernel, "main");
         kernel.MakeCurrentProcess(main_process.get());
@@ -199,6 +209,11 @@ struct System::Impl {
         // Close app loader
         app_loader.reset();
 
+        // Clear all applets
+        profile_selector.reset();
+        software_keyboard.reset();
+        web_browser.reset();
+
         LOG_DEBUG(Core, "Shutdown OK");
     }
 
@@ -233,6 +248,7 @@ struct System::Impl {
     /// Frontend applets
     std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_selector;
     std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
+    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -427,22 +443,34 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 
-void System::SetProfileSelector(std::unique_ptr<Core::Frontend::ProfileSelectApplet> applet) {
+void System::SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet) {
     impl->profile_selector = std::move(applet);
 }
 
-const Core::Frontend::ProfileSelectApplet& System::GetProfileSelector() const {
+const Frontend::ProfileSelectApplet& System::GetProfileSelector() const {
     return *impl->profile_selector;
 }
 
-void System::SetSoftwareKeyboard(std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> applet) {
+void System::SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet) {
     impl->software_keyboard = std::move(applet);
 }
 
-const Core::Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
+const Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
     return *impl->software_keyboard;
 }
 
+void System::SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet) {
+    impl->web_browser = std::move(applet);
+}
+
+Frontend::WebBrowserApplet& System::GetWebBrowser() {
+    return *impl->web_browser;
+}
+
+const Frontend::WebBrowserApplet& System::GetWebBrowser() const {
+    return *impl->web_browser;
+}
+
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
     return impl->Init(*this, emu_window);
 }

src/core/core.h

@@ -11,11 +11,12 @@
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/object.h"
-#include "frontend/applets/profile_select.h"
 
 namespace Core::Frontend {
 class EmuWindow;
+class ProfileSelectApplet;
 class SoftwareKeyboardApplet;
+class WebBrowserApplet;
 } // namespace Core::Frontend
 
 namespace FileSys {
@@ -242,13 +243,18 @@ public:
 
     std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
 
-    void SetProfileSelector(std::unique_ptr<Core::Frontend::ProfileSelectApplet> applet);
+    void SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet);
 
-    const Core::Frontend::ProfileSelectApplet& GetProfileSelector() const;
+    const Frontend::ProfileSelectApplet& GetProfileSelector() const;
 
-    void SetSoftwareKeyboard(std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> applet);
+    void SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet);
 
-    const Core::Frontend::SoftwareKeyboardApplet& GetSoftwareKeyboard() const;
+    const Frontend::SoftwareKeyboardApplet& GetSoftwareKeyboard() const;
+
+    void SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet);
+
+    Frontend::WebBrowserApplet& GetWebBrowser();
+    const Frontend::WebBrowserApplet& GetWebBrowser() const;
 
 private:
     System();

src/core/file_sys/content_archive.cpp

@@ -359,6 +359,8 @@ bool NCA::ReadPFS0Section(const NCASectionHeader& section, const NCASectionTable
             dirs.push_back(std::move(npfs));
             if (IsDirectoryExeFS(dirs.back()))
                 exefs = dirs.back();
+            else if (IsDirectoryLogoPartition(dirs.back()))
+                logo = dirs.back();
         } else {
             if (has_rights_id)
                 status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
@@ -546,4 +548,8 @@ u64 NCA::GetBaseIVFCOffset() const {
     return ivfc_offset;
 }
 
+VirtualDir NCA::GetLogoPartition() const {
+    return logo;
+}
+
 } // namespace FileSys

src/core/file_sys/content_archive.h

@@ -74,6 +74,13 @@ inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
     return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
 }
 
+inline bool IsDirectoryLogoPartition(const VirtualDir& pfs) {
+    // NintendoLogo is the static image in the top left corner while StartupMovie is the animation
+    // in the bottom right corner.
+    return pfs->GetFile("NintendoLogo.png") != nullptr &&
+           pfs->GetFile("StartupMovie.gif") != nullptr;
+}
+
 // An implementation of VfsDirectory that represents a Nintendo Content Archive (NCA) conatiner.
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
@@ -102,6 +109,8 @@ public:
     // Returns the base ivfc offset used in BKTR patching.
     u64 GetBaseIVFCOffset() const;
 
+    VirtualDir GetLogoPartition() const;
+
 private:
     bool CheckSupportedNCA(const NCAHeader& header);
     bool HandlePotentialHeaderDecryption();
@@ -122,6 +131,7 @@ private:
 
     VirtualFile romfs = nullptr;
     VirtualDir exefs = nullptr;
+    VirtualDir logo = nullptr;
     VirtualFile file;
     VirtualFile bktr_base_romfs;
     u64 ivfc_offset = 0;

src/core/file_sys/directory.h

@@ -39,27 +39,4 @@ static_assert(sizeof(Entry) == 0x310, "Directory Entry struct isn't exactly 0x31
 static_assert(offsetof(Entry, type) == 0x304, "Wrong offset for type in Entry.");
 static_assert(offsetof(Entry, file_size) == 0x308, "Wrong offset for file_size in Entry.");
 
-class DirectoryBackend : NonCopyable {
-public:
-    DirectoryBackend() {}
-    virtual ~DirectoryBackend() {}
-
-    /**
-     * List files contained in the directory
-     * @param count Number of entries to return at once in entries
-     * @param entries Buffer to read data into
-     * @return Number of entries listed
-     */
-    virtual u64 Read(const u64 count, Entry* entries) = 0;
-
-    /// Returns the number of entries still left to read.
-    virtual u64 GetEntryCount() const = 0;
-
-    /**
-     * Close the directory
-     * @return true if the directory closed correctly
-     */
-    virtual bool Close() const = 0;
-};
-
 } // namespace FileSys

src/core/file_sys/romfs.cpp

@@ -119,6 +119,9 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
 
     VirtualDir out = std::move(root);
 
+    if (type == RomFSExtractionType::SingleDiscard)
+        return out->GetSubdirectories().front();
+
     while (out->GetSubdirectories().size() == 1 && out->GetFiles().empty()) {
         if (out->GetSubdirectories().front()->GetName() == "data" &&
             type == RomFSExtractionType::Truncated)

src/core/file_sys/romfs.h

@@ -33,8 +33,9 @@ struct IVFCHeader {
 static_assert(sizeof(IVFCHeader) == 0xE0, "IVFCHeader has incorrect size.");
 
 enum class RomFSExtractionType {
-    Full,      // Includes data directory
-    Truncated, // Traverses into data directory
+    Full,          // Includes data directory
+    Truncated,     // Traverses into data directory
+    SingleDiscard, // Traverses into the first subdirectory of root
 };
 
 // Converts a RomFS binary blob to VFS Filesystem

src/core/frontend/applets/web_browser.cpp

@@ -0,0 +1,24 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "core/frontend/applets/web_browser.h"
+
+namespace Core::Frontend {
+
+WebBrowserApplet::~WebBrowserApplet() = default;
+
+DefaultWebBrowserApplet::~DefaultWebBrowserApplet() = default;
+
+void DefaultWebBrowserApplet::OpenPage(std::string_view filename,
+                                       std::function<void()> unpack_romfs_callback,
+                                       std::function<void()> finished_callback) {
+    LOG_INFO(Service_AM,
+             "(STUBBED) called - No suitable web browser implementation found to open website page "
+             "at '{}'!",
+             filename);
+    finished_callback();
+}
+
+} // namespace Core::Frontend

src/core/frontend/applets/web_browser.h

@@ -0,0 +1,28 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <string_view>
+
+namespace Core::Frontend {
+
+class WebBrowserApplet {
+public:
+    virtual ~WebBrowserApplet();
+
+    virtual void OpenPage(std::string_view url, std::function<void()> unpack_romfs_callback,
+                          std::function<void()> finished_callback) = 0;
+};
+
+class DefaultWebBrowserApplet final : public WebBrowserApplet {
+public:
+    ~DefaultWebBrowserApplet() override;
+
+    void OpenPage(std::string_view url, std::function<void()> unpack_romfs_callback,
+                  std::function<void()> finished_callback) override;
+};
+
+} // namespace Core::Frontend

src/core/hle/ipc_helpers.h

@@ -18,7 +18,7 @@
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/object.h"
-#include "core/hle/kernel/server_port.h"
+#include "core/hle/kernel/server_session.h"
 
 namespace IPC {
 

src/core/hle/kernel/client_session.cpp

@@ -8,6 +8,7 @@
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/session.h"
 #include "core/hle/kernel/thread.h"
+#include "core/hle/result.h"
 
 namespace Kernel {
 

src/core/hle/kernel/client_session.h

@@ -6,9 +6,9 @@
 
 #include <memory>
 #include <string>
-#include "common/common_types.h"
 #include "core/hle/kernel/object.h"
-#include "core/hle/result.h"
+
+union ResultCode;
 
 namespace Kernel {
 

src/core/hle/kernel/hle_ipc.cpp

@@ -22,11 +22,16 @@
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/server_session.h"
+#include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/memory.h"
 
 namespace Kernel {
 
+SessionRequestHandler::SessionRequestHandler() = default;
+
+SessionRequestHandler::~SessionRequestHandler() = default;
+
 void SessionRequestHandler::ClientConnected(SharedPtr<ServerSession> server_session) {
     server_session->SetHleHandler(shared_from_this());
     connected_sessions.push_back(std::move(server_session));

src/core/hle/kernel/hle_ipc.h

@@ -14,8 +14,6 @@
 #include "common/swap.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/object.h"
-#include "core/hle/kernel/server_session.h"
-#include "core/hle/kernel/thread.h"
 
 namespace Service {
 class ServiceFrameworkBase;
@@ -27,9 +25,13 @@ class Domain;
 class HandleTable;
 class HLERequestContext;
 class Process;
+class ServerSession;
+class Thread;
 class ReadableEvent;
 class WritableEvent;
 
+enum class ThreadWakeupReason;
+
 /**
  * Interface implemented by HLE Session handlers.
  * This can be provided to a ServerSession in order to hook into several relevant events
@@ -37,7 +39,8 @@ class WritableEvent;
  */
 class SessionRequestHandler : public std::enable_shared_from_this<SessionRequestHandler> {
 public:
-    virtual ~SessionRequestHandler() = default;
+    SessionRequestHandler();
+    virtual ~SessionRequestHandler();
 
     /**
      * Handles a sync request from the emulated application.

src/core/hle/kernel/kernel.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
 #include <atomic>
 #include <memory>
 #include <mutex>

src/core/hle/kernel/object.h

@@ -36,7 +36,6 @@ enum class HandleType : u32 {
 enum class ResetType {
     OneShot, ///< Reset automatically on object acquisition
     Sticky,  ///< Never reset automatically
-    Pulse,   ///< Reset automatically on wakeup
 };
 
 class Object : NonCopyable {

src/core/hle/kernel/process.h

@@ -14,7 +14,6 @@
 #include "common/common_types.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/process_capability.h"
-#include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/hle/kernel/wait_object.h"
 #include "core/hle/result.h"
@@ -27,6 +26,7 @@ namespace Kernel {
 
 class KernelCore;
 class ResourceLimit;
+class Thread;
 
 struct AddressMapping {
     // Address and size must be page-aligned

src/core/hle/kernel/readable_event.cpp

@@ -46,9 +46,6 @@ ResultCode ReadableEvent::Reset() {
 
 void ReadableEvent::WakeupAllWaitingThreads() {
     WaitObject::WakeupAllWaitingThreads();
-
-    if (reset_type == ResetType::Pulse)
-        signaled = false;
 }
 
 } // namespace Kernel

src/core/hle/kernel/server_session.cpp

@@ -6,6 +6,7 @@
 #include <utility>
 
 #include "common/assert.h"
+#include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"

src/core/hle/kernel/server_session.h

@@ -8,7 +8,6 @@
 #include <string>
 #include <vector>
 
-#include "common/common_types.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/wait_object.h"
 #include "core/hle/result.h"

src/core/hle/kernel/timer.cpp

@@ -68,9 +68,6 @@ void Timer::Clear() {
 
 void Timer::WakeupAllWaitingThreads() {
     WaitObject::WakeupAllWaitingThreads();
-
-    if (reset_type == ResetType::Pulse)
-        signaled = false;
 }
 
 void Timer::Signal(int cycles_late) {

src/core/hle/kernel/wait_object.cpp

@@ -4,11 +4,11 @@
 
 #include <algorithm>
 #include "common/assert.h"
+#include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/kernel/timer.h"
 
 namespace Kernel {
 

src/core/hle/kernel/wait_object.h

@@ -6,7 +6,6 @@
 
 #include <vector>
 #include <boost/smart_ptr/intrusive_ptr.hpp>
-#include "common/common_types.h"
 #include "core/hle/kernel/object.h"
 
 namespace Kernel {

src/core/hle/kernel/writable_event.h

@@ -4,9 +4,7 @@
 
 #pragma once
 
-#include "common/common_types.h"
 #include "core/hle/kernel/object.h"
-#include "core/hle/kernel/wait_object.h"
 
 namespace Kernel {
 

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

@@ -23,6 +23,7 @@
 #include "core/hle/service/am/applets/profile_select.h"
 #include "core/hle/service/am/applets/software_keyboard.h"
 #include "core/hle/service/am/applets/stub_applet.h"
+#include "core/hle/service/am/applets/web_browser.h"
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
@@ -38,11 +39,13 @@
 namespace Service::AM {
 
 constexpr ResultCode ERR_NO_DATA_IN_CHANNEL{ErrorModule::AM, 0x2};
+constexpr ResultCode ERR_NO_MESSAGES{ErrorModule::AM, 0x3};
 constexpr ResultCode ERR_SIZE_OUT_OF_BOUNDS{ErrorModule::AM, 0x1F7};
 
 enum class AppletId : u32 {
     ProfileSelect = 0x10,
     SoftwareKeyboard = 0x11,
+    LibAppletOff = 0x17,
 };
 
 constexpr u32 POP_LAUNCH_PARAMETER_MAGIC = 0xC79497CA;
@@ -460,9 +463,17 @@ void ICommonStateGetter::GetEventHandle(Kernel::HLERequestContext& ctx) {
 void ICommonStateGetter::ReceiveMessage(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_AM, "called");
 
+    const auto message = msg_queue->PopMessage();
     IPC::ResponseBuilder rb{ctx, 3};
+
+    if (message == AppletMessageQueue::AppletMessage::NoMessage) {
+        LOG_ERROR(Service_AM, "Message queue is empty");
+        rb.Push(ERR_NO_MESSAGES);
+        rb.PushEnum<AppletMessageQueue::AppletMessage>(message);
+        return;
+    }
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum<AppletMessageQueue::AppletMessage>(msg_queue->PopMessage());
+    rb.PushEnum<AppletMessageQueue::AppletMessage>(message);
 }
 
 void ICommonStateGetter::GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
@@ -721,10 +732,10 @@ void IStorageAccessor::Write(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const u64 offset{rp.Pop<u64>()};
-    LOG_DEBUG(Service_AM, "called, offset={}", offset);
-
     const std::vector<u8> data{ctx.ReadBuffer()};
 
+    LOG_DEBUG(Service_AM, "called, offset={}, size={}", offset, data.size());
+
     if (data.size() > backing.buffer.size() - offset) {
         LOG_ERROR(Service_AM,
                   "offset is out of bounds, backing_buffer_sz={}, data_size={}, offset={}",
@@ -744,10 +755,10 @@ void IStorageAccessor::Read(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const u64 offset{rp.Pop<u64>()};
-    LOG_DEBUG(Service_AM, "called, offset={}", offset);
-
     const std::size_t size{ctx.GetWriteBufferSize()};
 
+    LOG_DEBUG(Service_AM, "called, offset={}, size={}", offset, size);
+
     if (size > backing.buffer.size() - offset) {
         LOG_ERROR(Service_AM, "offset is out of bounds, backing_buffer_sz={}, size={}, offset={}",
                   backing.buffer.size(), size, offset);
@@ -782,6 +793,8 @@ static std::shared_ptr<Applets::Applet> GetAppletFromId(AppletId id) {
         return std::make_shared<Applets::ProfileSelect>();
     case AppletId::SoftwareKeyboard:
         return std::make_shared<Applets::SoftwareKeyboard>();
+    case AppletId::LibAppletOff:
+        return std::make_shared<Applets::WebBrowser>();
     default:
         LOG_ERROR(Service_AM, "Unimplemented AppletId [{:08X}]! -- Falling back to stub!",
                   static_cast<u32>(id));

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

@@ -6,7 +6,7 @@
 #include "common/assert.h"
 #include "core/core.h"
 #include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/server_port.h"
+#include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applets.h"

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

@@ -7,7 +7,7 @@
 #include <memory>
 #include <queue>
 #include "common/swap.h"
-#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/object.h"
 #include "core/hle/kernel/writable_event.h"
 
 union ResultCode;

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

@@ -7,7 +7,7 @@
 #include "common/assert.h"
 #include "common/string_util.h"
 #include "core/core.h"
-#include "core/frontend/applets/software_keyboard.h"
+#include "core/frontend/applets/profile_select.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/profile_select.h"
 

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

@@ -0,0 +1,190 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <array>
+#include <cstring>
+#include <vector>
+
+#include "common/assert.h"
+#include "common/common_funcs.h"
+#include "common/common_paths.h"
+#include "common/file_util.h"
+#include "common/hex_util.h"
+#include "common/logging/log.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/mode.h"
+#include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/file_sys/romfs.h"
+#include "core/file_sys/vfs_types.h"
+#include "core/frontend/applets/web_browser.h"
+#include "core/hle/kernel/process.h"
+#include "core/hle/service/am/applets/web_browser.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/loader/loader.h"
+
+namespace Service::AM::Applets {
+
+// TODO(DarkLordZach): There are other arguments in the WebBuffer structure that are currently not
+// parsed, for example footer mode and left stick mode. Some of these are not particularly relevant,
+// but some may be worth an implementation.
+constexpr u16 WEB_ARGUMENT_URL_TYPE = 0x6;
+
+struct WebBufferHeader {
+    u16 count;
+    INSERT_PADDING_BYTES(6);
+};
+static_assert(sizeof(WebBufferHeader) == 0x8, "WebBufferHeader has incorrect size.");
+
+struct WebArgumentHeader {
+    u16 type;
+    u16 size;
+    u32 offset;
+};
+static_assert(sizeof(WebArgumentHeader) == 0x8, "WebArgumentHeader has incorrect size.");
+
+struct WebArgumentResult {
+    u32 result_code;
+    std::array<char, 0x1000> last_url;
+    u64 last_url_size;
+};
+static_assert(sizeof(WebArgumentResult) == 0x1010, "WebArgumentResult has incorrect size.");
+
+static std::vector<u8> GetArgumentDataForTagType(const std::vector<u8>& data, u16 type) {
+    WebBufferHeader header;
+    ASSERT(sizeof(WebBufferHeader) <= data.size());
+    std::memcpy(&header, data.data(), sizeof(WebBufferHeader));
+
+    u64 offset = sizeof(WebBufferHeader);
+    for (u16 i = 0; i < header.count; ++i) {
+        WebArgumentHeader arg;
+        ASSERT(offset + sizeof(WebArgumentHeader) <= data.size());
+        std::memcpy(&arg, data.data() + offset, sizeof(WebArgumentHeader));
+        offset += sizeof(WebArgumentHeader);
+
+        if (arg.type == type) {
+            std::vector<u8> out(arg.size);
+            offset += arg.offset;
+            ASSERT(offset + arg.size <= data.size());
+            std::memcpy(out.data(), data.data() + offset, out.size());
+            return out;
+        }
+
+        offset += arg.offset + arg.size;
+    }
+
+    return {};
+}
+
+static FileSys::VirtualFile GetManualRomFS() {
+    auto& loader{Core::System::GetInstance().GetAppLoader()};
+
+    FileSys::VirtualFile out;
+    if (loader.ReadManualRomFS(out) == Loader::ResultStatus::Success)
+        return out;
+
+    const auto& installed{FileSystem::GetUnionContents()};
+    const auto res = installed.GetEntry(Core::System::GetInstance().CurrentProcess()->GetTitleID(),
+                                        FileSys::ContentRecordType::Manual);
+
+    if (res != nullptr)
+        return res->GetRomFS();
+    return nullptr;
+}
+
+WebBrowser::WebBrowser() = default;
+
+WebBrowser::~WebBrowser() = default;
+
+void WebBrowser::Initialize() {
+    Applet::Initialize();
+
+    complete = false;
+    temporary_dir.clear();
+    filename.clear();
+    status = RESULT_SUCCESS;
+
+    const auto web_arg_storage = broker.PopNormalDataToApplet();
+    ASSERT(web_arg_storage != nullptr);
+    const auto& web_arg = web_arg_storage->GetData();
+
+    const auto url_data = GetArgumentDataForTagType(web_arg, WEB_ARGUMENT_URL_TYPE);
+    filename = Common::StringFromFixedZeroTerminatedBuffer(
+        reinterpret_cast<const char*>(url_data.data()), url_data.size());
+
+    temporary_dir = FileUtil::SanitizePath(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) +
+                                               "web_applet_manual",
+                                           FileUtil::DirectorySeparator::PlatformDefault);
+    FileUtil::DeleteDirRecursively(temporary_dir);
+
+    manual_romfs = GetManualRomFS();
+    if (manual_romfs == nullptr) {
+        status = ResultCode(-1);
+        LOG_ERROR(Service_AM, "Failed to find manual for current process!");
+    }
+
+    filename =
+        FileUtil::SanitizePath(temporary_dir + DIR_SEP + "html-document" + DIR_SEP + filename,
+                               FileUtil::DirectorySeparator::PlatformDefault);
+}
+
+bool WebBrowser::TransactionComplete() const {
+    return complete;
+}
+
+ResultCode WebBrowser::GetStatus() const {
+    return status;
+}
+
+void WebBrowser::ExecuteInteractive() {
+    UNIMPLEMENTED_MSG("Unexpected interactive data recieved!");
+}
+
+void WebBrowser::Execute() {
+    if (complete)
+        return;
+
+    if (status != RESULT_SUCCESS) {
+        complete = true;
+        return;
+    }
+
+    auto& frontend{Core::System::GetInstance().GetWebBrowser()};
+
+    frontend.OpenPage(filename, [this] { UnpackRomFS(); }, [this] { Finalize(); });
+}
+
+void WebBrowser::UnpackRomFS() {
+    if (unpacked)
+        return;
+
+    ASSERT(manual_romfs != nullptr);
+    const auto dir =
+        FileSys::ExtractRomFS(manual_romfs, FileSys::RomFSExtractionType::SingleDiscard);
+    const auto& vfs{Core::System::GetInstance().GetFilesystem()};
+    const auto temp_dir = vfs->CreateDirectory(temporary_dir, FileSys::Mode::ReadWrite);
+    FileSys::VfsRawCopyD(dir, temp_dir);
+
+    unpacked = true;
+}
+
+void WebBrowser::Finalize() {
+    complete = true;
+
+    WebArgumentResult out{};
+    out.result_code = 0;
+    out.last_url_size = 0;
+
+    std::vector<u8> data(sizeof(WebArgumentResult));
+    std::memcpy(data.data(), &out, sizeof(WebArgumentResult));
+
+    broker.PushNormalDataFromApplet(IStorage{data});
+    broker.SignalStateChanged();
+
+    FileUtil::DeleteDirRecursively(temporary_dir);
+}
+
+} // namespace Service::AM::Applets

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

@@ -0,0 +1,44 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/file_sys/vfs_types.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/applets.h"
+
+namespace Service::AM::Applets {
+
+class WebBrowser final : public Applet {
+public:
+    WebBrowser();
+    ~WebBrowser() override;
+
+    void Initialize() override;
+
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+
+    // Callback to be fired when the frontend needs the manual RomFS unpacked to temporary
+    // directory. This is a blocking call and may take a while as some manuals can be up to 100MB in
+    // size. Attempting to access files at filename before invocation is likely to not work.
+    void UnpackRomFS();
+
+    // Callback to be fired when the frontend is finished browsing. This will delete the temporary
+    // manual RomFS extracted files, so ensure this is only called at actual finalization.
+    void Finalize();
+
+private:
+    bool complete = false;
+    bool unpacked = false;
+    ResultCode status = RESULT_SUCCESS;
+
+    FileSys::VirtualFile manual_romfs;
+    std::string temporary_dir;
+    std::string filename;
+};
+
+} // namespace Service::AM::Applets

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

@@ -410,6 +410,8 @@ void Controller_NPad::OnUpdate(u8* data, std::size_t data_len) {
         libnx_entry.pad.pad_states.raw = pad_state.pad_states.raw;
         libnx_entry.pad.l_stick = pad_state.l_stick;
         libnx_entry.pad.r_stick = pad_state.r_stick;
+
+        press_state |= static_cast<u32>(pad_state.pad_states.raw);
     }
     std::memcpy(data + NPAD_OFFSET, shared_memory_entries.data(),
                 shared_memory_entries.size() * sizeof(NPadEntry));
@@ -636,6 +638,10 @@ void Controller_NPad::ClearAllControllers() {
                   });
 }
 
+u32 Controller_NPad::GetAndResetPressState() {
+    return std::exchange(press_state, 0);
+}
+
 bool Controller_NPad::IsControllerSupported(NPadControllerType controller) const {
     const bool support_handheld =
         std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(), NPAD_HANDHELD) !=

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

@@ -124,6 +124,10 @@ public:
     void ConnectAllDisconnectedControllers();
     void ClearAllControllers();
 
+    // Logical OR for all buttons presses on all controllers
+    // Specifically for cheat engine and other features.
+    u32 GetAndResetPressState();
+
     static std::size_t NPadIdToIndex(u32 npad_id);
     static u32 IndexToNPad(std::size_t index);
 
@@ -292,6 +296,8 @@ private:
         bool is_connected;
     };
 
+    u32 press_state{};
+
     NPadType style{};
     std::array<NPadEntry, 10> shared_memory_entries{};
     std::array<

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

@@ -4,12 +4,122 @@
 
 #pragma once
 
+#include "controllers/controller_base.h"
+#include "core/hle/service/service.h"
+
+namespace CoreTiming {
+struct EventType;
+}
+
+namespace Kernel {
+class SharedMemory;
+}
+
 namespace SM {
 class ServiceManager;
 }
 
 namespace Service::HID {
 
+enum class HidController : std::size_t {
+    DebugPad,
+    Touchscreen,
+    Mouse,
+    Keyboard,
+    XPad,
+    Unknown1,
+    Unknown2,
+    Unknown3,
+    SixAxisSensor,
+    NPad,
+    Gesture,
+
+    MaxControllers,
+};
+
+class IAppletResource final : public ServiceFramework<IAppletResource> {
+public:
+    IAppletResource();
+    ~IAppletResource() override;
+
+    void ActivateController(HidController controller);
+    void DeactivateController(HidController controller);
+
+    template <typename T>
+    T& GetController(HidController controller) {
+        return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
+    }
+
+    template <typename T>
+    const T& GetController(HidController controller) const {
+        return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
+    }
+
+private:
+    template <typename T>
+    void MakeController(HidController controller) {
+        controllers[static_cast<std::size_t>(controller)] = std::make_unique<T>();
+    }
+
+    void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
+    void UpdateControllers(u64 userdata, int cycles_late);
+
+    Kernel::SharedPtr<Kernel::SharedMemory> shared_mem;
+
+    CoreTiming::EventType* pad_update_event;
+
+    std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>
+        controllers{};
+};
+
+class Hid final : public ServiceFramework<Hid> {
+public:
+    Hid();
+    ~Hid() override;
+
+    std::shared_ptr<IAppletResource> GetAppletResource();
+
+private:
+    void CreateAppletResource(Kernel::HLERequestContext& ctx);
+    void ActivateXpad(Kernel::HLERequestContext& ctx);
+    void ActivateDebugPad(Kernel::HLERequestContext& ctx);
+    void ActivateTouchScreen(Kernel::HLERequestContext& ctx);
+    void ActivateMouse(Kernel::HLERequestContext& ctx);
+    void ActivateKeyboard(Kernel::HLERequestContext& ctx);
+    void ActivateGesture(Kernel::HLERequestContext& ctx);
+    void ActivateNpadWithRevision(Kernel::HLERequestContext& ctx);
+    void StartSixAxisSensor(Kernel::HLERequestContext& ctx);
+    void SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx);
+    void IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx);
+    void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx);
+    void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx);
+    void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx);
+    void ActivateNpad(Kernel::HLERequestContext& ctx);
+    void AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx);
+    void DisconnectNpad(Kernel::HLERequestContext& ctx);
+    void GetPlayerLedPattern(Kernel::HLERequestContext& ctx);
+    void SetNpadJoyHoldType(Kernel::HLERequestContext& ctx);
+    void GetNpadJoyHoldType(Kernel::HLERequestContext& ctx);
+    void SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx);
+    void BeginPermitVibrationSession(Kernel::HLERequestContext& ctx);
+    void EndPermitVibrationSession(Kernel::HLERequestContext& ctx);
+    void SendVibrationValue(Kernel::HLERequestContext& ctx);
+    void SendVibrationValues(Kernel::HLERequestContext& ctx);
+    void GetActualVibrationValue(Kernel::HLERequestContext& ctx);
+    void SetNpadJoyAssignmentModeDual(Kernel::HLERequestContext& ctx);
+    void MergeSingleJoyAsDualJoy(Kernel::HLERequestContext& ctx);
+    void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx);
+    void GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx);
+    void CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx);
+    void ActivateConsoleSixAxisSensor(Kernel::HLERequestContext& ctx);
+    void StartConsoleSixAxisSensor(Kernel::HLERequestContext& ctx);
+    void StopSixAxisSensor(Kernel::HLERequestContext& ctx);
+    void SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx);
+    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx);
+
+    std::shared_ptr<IAppletResource> applet_resource;
+};
+
 /// Reload input devices. Used when input configuration changed
 void ReloadInputDevices();
 

src/core/hle/service/nfp/nfp.cpp

@@ -9,9 +9,9 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/readable_event.h"
+#include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/lock.h"
-#include "core/hle/service/hid/hid.h"
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nfp/nfp_user.h"
 
@@ -20,7 +20,8 @@ namespace Service::NFP {
 namespace ErrCodes {
 constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP,
                                     -1); // TODO(ogniK): Find the actual error code
-}
+constexpr ResultCode ERR_NO_APPLICATION_AREA(ErrorModule::NFP, 152);
+} // namespace ErrCodes
 
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
     : ServiceFramework(name), module(std::move(module)) {
@@ -292,10 +293,9 @@ private:
     }
 
     void OpenApplicationArea(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-        // We don't need to worry about this since we can just open the file
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
+        rb.Push(ErrCodes::ERR_NO_APPLICATION_AREA);
     }
 
     void GetApplicationAreaSize(Kernel::HLERequestContext& ctx) {

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -166,7 +166,7 @@ Layer::~Layer() = default;
 
 Display::Display(u64 id, std::string name) : id(id), name(std::move(name)) {
     auto& kernel = Core::System::GetInstance().Kernel();
-    vsync_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Pulse,
+    vsync_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
                                                          fmt::format("Display VSync Event {}", id));
 }
 

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

@@ -12,9 +12,16 @@
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/service/time/interface.h"
 #include "core/hle/service/time/time.h"
+#include "core/settings.h"
 
 namespace Service::Time {
 
+static std::chrono::seconds GetSecondsSinceEpoch() {
+    return std::chrono::duration_cast<std::chrono::seconds>(
+               std::chrono::system_clock::now().time_since_epoch()) +
+           Settings::values.custom_rtc_differential;
+}
+
 static void PosixToCalendar(u64 posix_time, CalendarTime& calendar_time,
                             CalendarAdditionalInfo& additional_info,
                             [[maybe_unused]] const TimeZoneRule& /*rule*/) {
@@ -68,9 +75,7 @@ public:
 
 private:
     void GetCurrentTime(Kernel::HLERequestContext& ctx) {
-        const s64 time_since_epoch{std::chrono::duration_cast<std::chrono::seconds>(
-                                       std::chrono::system_clock::now().time_since_epoch())
-                                       .count()};
+        const s64 time_since_epoch{GetSecondsSinceEpoch().count()};
         LOG_DEBUG(Service_Time, "called");
 
         IPC::ResponseBuilder rb{ctx, 4};
@@ -266,10 +271,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto initial_type = rp.PopRaw<u8>();
 
-    const s64 time_since_epoch{std::chrono::duration_cast<std::chrono::seconds>(
-                                   std::chrono::system_clock::now().time_since_epoch())
-                                   .count()};
-
+    const s64 time_since_epoch{GetSecondsSinceEpoch().count()};
     const std::time_t time(time_since_epoch);
     const std::tm* tm = std::localtime(&time);
     if (tm == nullptr) {

src/core/hle/service/vi/vi.cpp

@@ -19,6 +19,7 @@
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/readable_event.h"
+#include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
@@ -31,12 +32,26 @@
 
 namespace Service::VI {
 
+constexpr ResultCode ERR_OPERATION_FAILED{ErrorModule::VI, 1};
+constexpr ResultCode ERR_UNSUPPORTED{ErrorModule::VI, 6};
+
 struct DisplayInfo {
+    /// The name of this particular display.
     char display_name[0x40]{"Default"};
-    u64 unknown_1{1};
-    u64 unknown_2{1};
-    u64 width{1280};
-    u64 height{720};
+
+    /// Whether or not the display has a limited number of layers.
+    u8 has_limited_layers{1};
+    INSERT_PADDING_BYTES(7){};
+
+    /// Indicates the total amount of layers supported by the display.
+    /// @note This is only valid if has_limited_layers is set.
+    u64 max_layers{1};
+
+    /// Maximum width in pixels.
+    u64 width{1920};
+
+    /// Maximum height in pixels.
+    u64 height{1080};
 };
 static_assert(sizeof(DisplayInfo) == 0x60, "DisplayInfo has wrong size");
 
@@ -862,6 +877,22 @@ public:
     ~IApplicationDisplayService() = default;
 
 private:
+    enum class ConvertedScaleMode : u64 {
+        Freeze = 0,
+        ScaleToWindow = 1,
+        ScaleAndCrop = 2,
+        None = 3,
+        PreserveAspectRatio = 4,
+    };
+
+    enum class NintendoScaleMode : u32 {
+        None = 0,
+        Freeze = 1,
+        ScaleToWindow = 2,
+        ScaleAndCrop = 3,
+        PreserveAspectRatio = 4,
+    };
+
     void GetRelayService(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_VI, "(STUBBED) called");
 
@@ -898,10 +929,23 @@ private:
         LOG_WARNING(Service_VI, "(STUBBED) called");
 
         IPC::RequestParser rp{ctx};
-        auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
-        auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
+        const auto name_buf = rp.PopRaw<std::array<char, 0x40>>();
 
-        std::string name(name_buf.begin(), end);
+        OpenDisplayImpl(ctx, std::string_view{name_buf.data(), name_buf.size()});
+    }
+
+    void OpenDefaultDisplay(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_VI, "called");
+
+        OpenDisplayImpl(ctx, "Default");
+    }
+
+    void OpenDisplayImpl(Kernel::HLERequestContext& ctx, std::string_view name) {
+        const auto trim_pos = name.find('\0');
+
+        if (trim_pos != std::string_view::npos) {
+            name.remove_suffix(name.size() - trim_pos);
+        }
 
         ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
 
@@ -920,37 +964,56 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
+    // This literally does nothing internally in the actual service itself,
+    // and just returns a successful result code regardless of the input.
+    void SetDisplayEnabled(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_VI, "called.");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
     void GetDisplayResolution(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const u64 display_id = rp.Pop<u64>();
 
-        LOG_WARNING(Service_VI, "(STUBBED) called. display_id=0x{:016X}", display_id);
+        LOG_DEBUG(Service_VI, "called. display_id=0x{:016X}", display_id);
 
         IPC::ResponseBuilder rb{ctx, 6};
         rb.Push(RESULT_SUCCESS);
 
-        if (Settings::values.use_docked_mode) {
-            rb.Push(static_cast<u64>(DisplayResolution::DockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor));
-            rb.Push(static_cast<u64>(DisplayResolution::DockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor));
-        } else {
-            rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor));
-            rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor));
-        }
+        // This only returns the fixed values of 1280x720 and makes no distinguishing
+        // between docked and undocked dimensions. We take the liberty of applying
+        // the resolution scaling factor here.
+        rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth) *
+                static_cast<u32>(Settings::values.resolution_factor));
+        rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight) *
+                static_cast<u32>(Settings::values.resolution_factor));
     }
 
     void SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const u32 scaling_mode = rp.Pop<u32>();
+        const auto scaling_mode = rp.PopEnum<NintendoScaleMode>();
         const u64 unknown = rp.Pop<u64>();
 
-        LOG_WARNING(Service_VI, "(STUBBED) called. scaling_mode=0x{:08X}, unknown=0x{:016X}",
-                    scaling_mode, unknown);
+        LOG_DEBUG(Service_VI, "called. scaling_mode=0x{:08X}, unknown=0x{:016X}",
+                  static_cast<u32>(scaling_mode), unknown);
 
         IPC::ResponseBuilder rb{ctx, 2};
+
+        if (scaling_mode > NintendoScaleMode::PreserveAspectRatio) {
+            LOG_ERROR(Service_VI, "Invalid scaling mode provided.");
+            rb.Push(ERR_OPERATION_FAILED);
+            return;
+        }
+
+        if (scaling_mode != NintendoScaleMode::ScaleToWindow &&
+            scaling_mode != NintendoScaleMode::PreserveAspectRatio) {
+            LOG_ERROR(Service_VI, "Unsupported scaling mode supplied.");
+            rb.Push(ERR_UNSUPPORTED);
+            return;
+        }
+
         rb.Push(RESULT_SUCCESS);
     }
 
@@ -1031,51 +1094,37 @@ private:
         rb.PushCopyObjects(vsync_event);
     }
 
-    enum class ConvertedScaleMode : u64 {
-        None = 0, // VI seems to name this as "Unknown" but lots of games pass it, assume it's no
-                  // scaling/default
-        Freeze = 1,
-        ScaleToWindow = 2,
-        Crop = 3,
-        NoCrop = 4,
-    };
-
-    // This struct is different, currently it's 1:1 but this might change in the future.
-    enum class NintendoScaleMode : u32 {
-        None = 0,
-        Freeze = 1,
-        ScaleToWindow = 2,
-        Crop = 3,
-        NoCrop = 4,
-    };
-
     void ConvertScalingMode(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        auto mode = rp.PopEnum<NintendoScaleMode>();
+        const auto mode = rp.PopEnum<NintendoScaleMode>();
         LOG_DEBUG(Service_VI, "called mode={}", static_cast<u32>(mode));
 
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
+        const auto converted_mode = ConvertScalingModeImpl(mode);
+
+        if (converted_mode.Succeeded()) {
+            IPC::ResponseBuilder rb{ctx, 4};
+            rb.Push(RESULT_SUCCESS);
+            rb.PushEnum(*converted_mode);
+        } else {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(converted_mode.Code());
+        }
+    }
+
+    static ResultVal<ConvertedScaleMode> ConvertScalingModeImpl(NintendoScaleMode mode) {
         switch (mode) {
         case NintendoScaleMode::None:
-            rb.PushEnum(ConvertedScaleMode::None);
-            break;
+            return MakeResult(ConvertedScaleMode::None);
         case NintendoScaleMode::Freeze:
-            rb.PushEnum(ConvertedScaleMode::Freeze);
-            break;
+            return MakeResult(ConvertedScaleMode::Freeze);
         case NintendoScaleMode::ScaleToWindow:
-            rb.PushEnum(ConvertedScaleMode::ScaleToWindow);
-            break;
-        case NintendoScaleMode::Crop:
-            rb.PushEnum(ConvertedScaleMode::Crop);
-            break;
-        case NintendoScaleMode::NoCrop:
-            rb.PushEnum(ConvertedScaleMode::NoCrop);
-            break;
+            return MakeResult(ConvertedScaleMode::ScaleToWindow);
+        case NintendoScaleMode::ScaleAndCrop:
+            return MakeResult(ConvertedScaleMode::ScaleAndCrop);
+        case NintendoScaleMode::PreserveAspectRatio:
+            return MakeResult(ConvertedScaleMode::PreserveAspectRatio);
         default:
-            UNIMPLEMENTED_MSG("Unknown scaling mode {}", static_cast<u32>(mode));
-            rb.PushEnum(ConvertedScaleMode::None);
-            break;
+            return ERR_OPERATION_FAILED;
         }
     }
 
@@ -1093,9 +1142,9 @@ IApplicationDisplayService::IApplicationDisplayService(
          "GetIndirectDisplayTransactionService"},
         {1000, &IApplicationDisplayService::ListDisplays, "ListDisplays"},
         {1010, &IApplicationDisplayService::OpenDisplay, "OpenDisplay"},
-        {1011, nullptr, "OpenDefaultDisplay"},
+        {1011, &IApplicationDisplayService::OpenDefaultDisplay, "OpenDefaultDisplay"},
         {1020, &IApplicationDisplayService::CloseDisplay, "CloseDisplay"},
-        {1101, nullptr, "SetDisplayEnabled"},
+        {1101, &IApplicationDisplayService::SetDisplayEnabled, "SetDisplayEnabled"},
         {1102, &IApplicationDisplayService::GetDisplayResolution, "GetDisplayResolution"},
         {2020, &IApplicationDisplayService::OpenLayer, "OpenLayer"},
         {2021, nullptr, "CloseLayer"},

src/core/loader/loader.h

@@ -178,6 +178,8 @@ public:
 
     /**
      * Get the banner (typically banner section) of the application
+     * In the context of NX, this is the animation that displays in the bottom right of the screen
+     * when a game boots. Stored in GIF format.
      * @param buffer Reference to buffer to store data
      * @return ResultStatus result of function
      */
@@ -187,6 +189,8 @@ public:
 
     /**
      * Get the logo (typically logo section) of the application
+     * In the context of NX, this is the static image that displays in the top left of the screen
+     * when a game boots. Stored in JPEG format.
      * @param buffer Reference to buffer to store data
      * @return ResultStatus result of function
      */
@@ -259,6 +263,15 @@ public:
         return ResultStatus::ErrorNotImplemented;
     }
 
+    /**
+     * Get the RomFS of the manual of the application
+     * @param file The raw manual RomFS of the game
+     * @return ResultStatus result of function
+     */
+    virtual ResultStatus ReadManualRomFS(FileSys::VirtualFile& file) {
+        return ResultStatus::ErrorNotImplemented;
+    }
+
 protected:
     FileSys::VirtualFile file;
     bool is_loaded = false;

src/core/loader/nax.cpp

@@ -79,4 +79,13 @@ u64 AppLoader_NAX::ReadRomFSIVFCOffset() const {
 ResultStatus AppLoader_NAX::ReadProgramId(u64& out_program_id) {
     return nca_loader->ReadProgramId(out_program_id);
 }
+
+ResultStatus AppLoader_NAX::ReadBanner(std::vector<u8>& buffer) {
+    return nca_loader->ReadBanner(buffer);
+}
+
+ResultStatus AppLoader_NAX::ReadLogo(std::vector<u8>& buffer) {
+    return nca_loader->ReadLogo(buffer);
+}
+
 } // namespace Loader

src/core/loader/nax.h

@@ -39,6 +39,9 @@ public:
     u64 ReadRomFSIVFCOffset() const override;
     ResultStatus ReadProgramId(u64& out_program_id) override;
 
+    ResultStatus ReadBanner(std::vector<u8>& buffer) override;
+    ResultStatus ReadLogo(std::vector<u8>& buffer) override;
+
 private:
     std::unique_ptr<FileSys::NAX> nax;
     std::unique_ptr<AppLoader_NCA> nca_loader;

src/core/loader/nca.cpp

@@ -84,4 +84,23 @@ ResultStatus AppLoader_NCA::ReadProgramId(u64& out_program_id) {
     return ResultStatus::Success;
 }
 
+ResultStatus AppLoader_NCA::ReadBanner(std::vector<u8>& buffer) {
+    if (nca == nullptr || nca->GetStatus() != ResultStatus::Success)
+        return ResultStatus::ErrorNotInitialized;
+    const auto logo = nca->GetLogoPartition();
+    if (logo == nullptr)
+        return ResultStatus::ErrorNoIcon;
+    buffer = logo->GetFile("StartupMovie.gif")->ReadAllBytes();
+    return ResultStatus::Success;
+}
+
+ResultStatus AppLoader_NCA::ReadLogo(std::vector<u8>& buffer) {
+    if (nca == nullptr || nca->GetStatus() != ResultStatus::Success)
+        return ResultStatus::ErrorNotInitialized;
+    const auto logo = nca->GetLogoPartition();
+    if (logo == nullptr)
+        return ResultStatus::ErrorNoIcon;
+    buffer = logo->GetFile("NintendoLogo.png")->ReadAllBytes();
+    return ResultStatus::Success;
+}
 } // namespace Loader

src/core/loader/nca.h

@@ -39,6 +39,9 @@ public:
     u64 ReadRomFSIVFCOffset() const override;
     ResultStatus ReadProgramId(u64& out_program_id) override;
 
+    ResultStatus ReadBanner(std::vector<u8>& buffer) override;
+    ResultStatus ReadLogo(std::vector<u8>& buffer) override;
+
 private:
     std::unique_ptr<FileSys::NCA> nca;
     std::unique_ptr<AppLoader_DeconstructedRomDirectory> directory_loader;

src/core/loader/nsp.cpp

@@ -158,4 +158,21 @@ ResultStatus AppLoader_NSP::ReadControlData(FileSys::NACP& nacp) {
     nacp = *nacp_file;
     return ResultStatus::Success;
 }
+
+ResultStatus AppLoader_NSP::ReadManualRomFS(FileSys::VirtualFile& file) {
+    const auto nca = nsp->GetNCA(nsp->GetProgramTitleID(), FileSys::ContentRecordType::Manual);
+    if (nsp->GetStatus() != ResultStatus::Success || nca == nullptr)
+        return ResultStatus::ErrorNoRomFS;
+    file = nca->GetRomFS();
+    return file == nullptr ? ResultStatus::ErrorNoRomFS : ResultStatus::Success;
+}
+
+ResultStatus AppLoader_NSP::ReadBanner(std::vector<u8>& buffer) {
+    return secondary_loader->ReadBanner(buffer);
+}
+
+ResultStatus AppLoader_NSP::ReadLogo(std::vector<u8>& buffer) {
+    return secondary_loader->ReadLogo(buffer);
+}
+
 } // namespace Loader

src/core/loader/nsp.h

@@ -44,6 +44,10 @@ public:
     ResultStatus ReadIcon(std::vector<u8>& buffer) override;
     ResultStatus ReadTitle(std::string& title) override;
     ResultStatus ReadControlData(FileSys::NACP& nacp) override;
+    ResultStatus ReadManualRomFS(FileSys::VirtualFile& file) override;
+
+    ResultStatus ReadBanner(std::vector<u8>& buffer) override;
+    ResultStatus ReadLogo(std::vector<u8>& buffer) override;
 
 private:
     std::unique_ptr<FileSys::NSP> nsp;

src/core/loader/xci.cpp

@@ -128,4 +128,21 @@ ResultStatus AppLoader_XCI::ReadControlData(FileSys::NACP& control) {
     return ResultStatus::Success;
 }
 
+ResultStatus AppLoader_XCI::ReadManualRomFS(FileSys::VirtualFile& file) {
+    const auto nca = xci->GetSecurePartitionNSP()->GetNCA(xci->GetProgramTitleID(),
+                                                          FileSys::ContentRecordType::Manual);
+    if (xci->GetStatus() != ResultStatus::Success || nca == nullptr)
+        return ResultStatus::ErrorXCIMissingPartition;
+    file = nca->GetRomFS();
+    return file == nullptr ? ResultStatus::ErrorNoRomFS : ResultStatus::Success;
+}
+
+ResultStatus AppLoader_XCI::ReadBanner(std::vector<u8>& buffer) {
+    return nca_loader->ReadBanner(buffer);
+}
+
+ResultStatus AppLoader_XCI::ReadLogo(std::vector<u8>& buffer) {
+    return nca_loader->ReadLogo(buffer);
+}
+
 } // namespace Loader

src/core/loader/xci.h

@@ -44,6 +44,10 @@ public:
     ResultStatus ReadIcon(std::vector<u8>& buffer) override;
     ResultStatus ReadTitle(std::string& title) override;
     ResultStatus ReadControlData(FileSys::NACP& control) override;
+    ResultStatus ReadManualRomFS(FileSys::VirtualFile& file) override;
+
+    ResultStatus ReadBanner(std::vector<u8>& buffer) override;
+    ResultStatus ReadLogo(std::vector<u8>& buffer) override;
 
 private:
     std::unique_ptr<FileSys::XCI> xci;

src/core/settings.h

@@ -6,6 +6,7 @@
 
 #include <array>
 #include <atomic>
+#include <chrono>
 #include <map>
 #include <optional>
 #include <string>
@@ -350,6 +351,11 @@ struct Values {
     bool use_docked_mode;
     bool enable_nfc;
     std::optional<u32> rng_seed;
+    // Measured in seconds since epoch
+    std::optional<std::chrono::seconds> custom_rtc;
+    // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
+    std::chrono::seconds custom_rtc_differential;
+
     s32 current_user;
     s32 language_index;
 

src/video_core/CMakeLists.txt

@@ -30,6 +30,8 @@ add_library(video_core STATIC
     renderer_base.h
     renderer_opengl/gl_buffer_cache.cpp
     renderer_opengl/gl_buffer_cache.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

src/video_core/engines/maxwell_3d.cpp

@@ -37,6 +37,7 @@ void Maxwell3D::InitializeRegisterDefaults() {
         regs.viewports[viewport].depth_range_near = 0.0f;
         regs.viewports[viewport].depth_range_far = 1.0f;
     }
+
     // Doom and Bomberman seems to use the uninitialized registers and just enable blend
     // so initialize blend registers with sane values
     regs.blend.equation_rgb = Regs::Blend::Equation::Add;
@@ -66,6 +67,7 @@ void Maxwell3D::InitializeRegisterDefaults() {
     regs.stencil_back_func_func = Regs::ComparisonOp::Always;
     regs.stencil_back_func_mask = 0xFFFFFFFF;
     regs.stencil_back_mask = 0xFFFFFFFF;
+
     // TODO(Rodrigo): Most games do not set a point size. I think this is a case of a
     // register carrying a default value. Assume it's OpenGL's default (1).
     regs.point_size = 1.0f;
@@ -78,6 +80,9 @@ void Maxwell3D::InitializeRegisterDefaults() {
         regs.color_mask[color_mask].B.Assign(1);
         regs.color_mask[color_mask].A.Assign(1);
     }
+
+    // Commercial games seem to assume this value is enabled and nouveau sets this value manually.
+    regs.rt_separate_frag_data = 1;
 }
 
 void Maxwell3D::CallMacroMethod(u32 method, std::vector<u32> parameters) {
@@ -135,6 +140,33 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
 
     if (regs.reg_array[method_call.method] != method_call.argument) {
         regs.reg_array[method_call.method] = method_call.argument;
+        // Color buffers
+        constexpr u32 first_rt_reg = MAXWELL3D_REG_INDEX(rt);
+        constexpr u32 registers_per_rt = sizeof(regs.rt[0]) / sizeof(u32);
+        if (method_call.method >= first_rt_reg &&
+            method_call.method < first_rt_reg + registers_per_rt * Regs::NumRenderTargets) {
+            const std::size_t rt_index = (method_call.method - first_rt_reg) / registers_per_rt;
+            dirty_flags.color_buffer |= 1u << static_cast<u32>(rt_index);
+        }
+
+        // Zeta buffer
+        constexpr u32 registers_in_zeta = sizeof(regs.zeta) / sizeof(u32);
+        if (method_call.method == MAXWELL3D_REG_INDEX(zeta_enable) ||
+            method_call.method == MAXWELL3D_REG_INDEX(zeta_width) ||
+            method_call.method == MAXWELL3D_REG_INDEX(zeta_height) ||
+            (method_call.method >= MAXWELL3D_REG_INDEX(zeta) &&
+             method_call.method < MAXWELL3D_REG_INDEX(zeta) + registers_in_zeta)) {
+            dirty_flags.zeta_buffer = true;
+        }
+
+        // Shader
+        constexpr u32 shader_registers_count =
+            sizeof(regs.shader_config[0]) * Regs::MaxShaderProgram / sizeof(u32);
+        if (method_call.method >= MAXWELL3D_REG_INDEX(shader_config[0]) &&
+            method_call.method < MAXWELL3D_REG_INDEX(shader_config[0]) + shader_registers_count) {
+            dirty_flags.shaders = true;
+        }
+
         // Vertex format
         if (method_call.method >= MAXWELL3D_REG_INDEX(vertex_attrib_format) &&
             method_call.method <

src/video_core/engines/maxwell_3d.h

@@ -1089,10 +1089,18 @@ public:
     MemoryManager& memory_manager;
 
     struct DirtyFlags {
+        u8 color_buffer = 0xFF;
+        bool zeta_buffer = true;
+
+        bool shaders = true;
+
         bool vertex_attrib_format = true;
         u32 vertex_array = 0xFFFFFFFF;
 
         void OnMemoryWrite() {
+            color_buffer = 0xFF;
+            zeta_buffer = true;
+            shaders = true;
             vertex_array = 0xFFFFFFFF;
         }
     };

src/video_core/rasterizer_interface.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <functional>
 #include "common/common_types.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/gpu.h"
@@ -11,6 +12,14 @@
 
 namespace VideoCore {
 
+enum class LoadCallbackStage {
+    Prepare,
+    Decompile,
+    Build,
+    Complete,
+};
+using DiskResourceLoadCallback = std::function<void(LoadCallbackStage, std::size_t, std::size_t)>;
+
 class RasterizerInterface {
 public:
     virtual ~RasterizerInterface() {}

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -14,7 +14,7 @@
 namespace OpenGL {
 
 OGLBufferCache::OGLBufferCache(RasterizerOpenGL& rasterizer, std::size_t size)
-    : RasterizerCache{rasterizer}, stream_buffer(GL_ARRAY_BUFFER, size) {}
+    : RasterizerCache{rasterizer}, stream_buffer(size, true) {}
 
 GLintptr OGLBufferCache::UploadMemory(Tegra::GPUVAddr gpu_addr, std::size_t size,
                                       std::size_t alignment, bool cache) {

src/video_core/renderer_opengl/gl_global_cache.cpp

@@ -0,0 +1,24 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <glad/glad.h>
+
+#include "video_core/renderer_opengl/gl_global_cache.h"
+#include "video_core/renderer_opengl/gl_rasterizer.h"
+#include "video_core/renderer_opengl/utils.h"
+
+namespace OpenGL {
+
+CachedGlobalRegion::CachedGlobalRegion(VAddr addr, u32 size) : addr{addr}, size{size} {
+    buffer.Create();
+    // Bind and unbind the buffer so it gets allocated by the driver
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer.handle);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+    LabelGLObject(GL_BUFFER, buffer.handle, addr, "GlobalMemory");
+}
+
+GlobalRegionCacheOpenGL::GlobalRegionCacheOpenGL(RasterizerOpenGL& rasterizer)
+    : RasterizerCache{rasterizer} {}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_global_cache.h

@@ -0,0 +1,60 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <glad/glad.h>
+
+#include "common/common_types.h"
+#include "video_core/rasterizer_cache.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace OpenGL {
+
+namespace GLShader {
+class GlobalMemoryEntry;
+} // namespace GLShader
+
+class RasterizerOpenGL;
+class CachedGlobalRegion;
+using GlobalRegion = std::shared_ptr<CachedGlobalRegion>;
+
+class CachedGlobalRegion final : public RasterizerCacheObject {
+public:
+    explicit CachedGlobalRegion(VAddr addr, u32 size);
+
+    /// Gets the address of the shader in guest memory, required for cache management
+    VAddr GetAddr() const {
+        return addr;
+    }
+
+    /// Gets the size of the shader in guest memory, required for cache management
+    std::size_t GetSizeInBytes() const {
+        return size;
+    }
+
+    /// Gets the GL program handle for the buffer
+    GLuint GetBufferHandle() const {
+        return buffer.handle;
+    }
+
+    // TODO(Rodrigo): When global memory is written (STG), implement flushing
+    void Flush() override {
+        UNIMPLEMENTED();
+    }
+
+private:
+    VAddr addr{};
+    u32 size{};
+
+    OGLBuffer buffer;
+};
+
+class GlobalRegionCacheOpenGL final : public RasterizerCache<GlobalRegion> {
+public:
+    explicit GlobalRegionCacheOpenGL(RasterizerOpenGL& rasterizer);
+};
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -101,7 +101,7 @@ struct FramebufferCacheKey {
 
 RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo& info)
     : res_cache{*this}, shader_cache{*this}, emu_window{window}, screen_info{info},
-      buffer_cache(*this, STREAM_BUFFER_SIZE) {
+      buffer_cache(*this, STREAM_BUFFER_SIZE), global_cache{*this} {
     // Create sampler objects
     for (std::size_t i = 0; i < texture_samplers.size(); ++i) {
         texture_samplers[i].Create();
@@ -135,27 +135,31 @@ void RasterizerOpenGL::CheckExtensions() {
     }
 }
 
-void RasterizerOpenGL::SetupVertexFormat() {
+GLuint RasterizerOpenGL::SetupVertexFormat() {
     auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
     const auto& regs = gpu.regs;
 
-    if (!gpu.dirty_flags.vertex_attrib_format)
-        return;
+    if (!gpu.dirty_flags.vertex_attrib_format) {
+        return state.draw.vertex_array;
+    }
     gpu.dirty_flags.vertex_attrib_format = false;
 
     MICROPROFILE_SCOPE(OpenGL_VAO);
 
     auto [iter, is_cache_miss] = vertex_array_cache.try_emplace(regs.vertex_attrib_format);
-    auto& VAO = iter->second;
+    auto& vao_entry = iter->second;
 
     if (is_cache_miss) {
-        VAO.Create();
-        state.draw.vertex_array = VAO.handle;
-        state.ApplyVertexBufferState();
+        vao_entry.Create();
+        const GLuint vao = vao_entry.handle;
 
-        // The index buffer binding is stored within the VAO. Stupid OpenGL, but easy to work
-        // around.
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer_cache.GetHandle());
+        // Eventhough we are using DSA to create this vertex array, there is a bug on Intel's blob
+        // that fails to properly create the vertex array if it's not bound even after creating it
+        // with glCreateVertexArrays
+        state.draw.vertex_array = vao;
+        state.ApplyVertexArrayState();
+
+        glVertexArrayElementBuffer(vao, buffer_cache.GetHandle());
 
         // Use the vertex array as-is, assumes that the data is formatted correctly for OpenGL.
         // Enables the first 16 vertex attributes always, as we don't know which ones are actually
@@ -163,7 +167,7 @@ void RasterizerOpenGL::SetupVertexFormat() {
         // for now to avoid OpenGL errors.
         // TODO(Subv): Analyze the shader to identify which attributes are actually used and don't
         // assume every shader uses them all.
-        for (unsigned index = 0; index < 16; ++index) {
+        for (u32 index = 0; index < 16; ++index) {
             const auto& attrib = regs.vertex_attrib_format[index];
 
             // Ignore invalid attributes.
@@ -178,28 +182,29 @@ void RasterizerOpenGL::SetupVertexFormat() {
 
             ASSERT(buffer.IsEnabled());
 
-            glEnableVertexAttribArray(index);
+            glEnableVertexArrayAttrib(vao, index);
             if (attrib.type == Tegra::Engines::Maxwell3D::Regs::VertexAttribute::Type::SignedInt ||
                 attrib.type ==
                     Tegra::Engines::Maxwell3D::Regs::VertexAttribute::Type::UnsignedInt) {
-                glVertexAttribIFormat(index, attrib.ComponentCount(),
-                                      MaxwellToGL::VertexType(attrib), attrib.offset);
+                glVertexArrayAttribIFormat(vao, index, attrib.ComponentCount(),
+                                           MaxwellToGL::VertexType(attrib), attrib.offset);
             } else {
-                glVertexAttribFormat(index, attrib.ComponentCount(),
-                                     MaxwellToGL::VertexType(attrib),
-                                     attrib.IsNormalized() ? GL_TRUE : GL_FALSE, attrib.offset);
+                glVertexArrayAttribFormat(
+                    vao, index, attrib.ComponentCount(), MaxwellToGL::VertexType(attrib),
+                    attrib.IsNormalized() ? GL_TRUE : GL_FALSE, attrib.offset);
             }
-            glVertexAttribBinding(index, attrib.buffer);
+            glVertexArrayAttribBinding(vao, index, attrib.buffer);
         }
     }
-    state.draw.vertex_array = VAO.handle;
-    state.ApplyVertexBufferState();
 
     // Rebinding the VAO invalidates the vertex buffer bindings.
     gpu.dirty_flags.vertex_array = 0xFFFFFFFF;
+
+    state.draw.vertex_array = vao_entry.handle;
+    return vao_entry.handle;
 }
 
-void RasterizerOpenGL::SetupVertexBuffer() {
+void RasterizerOpenGL::SetupVertexBuffer(GLuint vao) {
     auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
     const auto& regs = gpu.regs;
 
@@ -217,7 +222,7 @@ void RasterizerOpenGL::SetupVertexBuffer() {
         if (!vertex_array.IsEnabled())
             continue;
 
-        Tegra::GPUVAddr start = vertex_array.StartAddress();
+        const Tegra::GPUVAddr start = vertex_array.StartAddress();
         const Tegra::GPUVAddr end = regs.vertex_array_limit[index].LimitAddress();
 
         ASSERT(end > start);
@@ -225,21 +230,18 @@ void RasterizerOpenGL::SetupVertexBuffer() {
         const GLintptr vertex_buffer_offset = buffer_cache.UploadMemory(start, size);
 
         // Bind the vertex array to the buffer at the current offset.
-        glBindVertexBuffer(index, buffer_cache.GetHandle(), vertex_buffer_offset,
-                           vertex_array.stride);
+        glVertexArrayVertexBuffer(vao, index, buffer_cache.GetHandle(), vertex_buffer_offset,
+                                  vertex_array.stride);
 
         if (regs.instanced_arrays.IsInstancingEnabled(index) && vertex_array.divisor != 0) {
             // Enable vertex buffer instancing with the specified divisor.
-            glVertexBindingDivisor(index, vertex_array.divisor);
+            glVertexArrayBindingDivisor(vao, index, vertex_array.divisor);
         } else {
             // Disable the vertex buffer instancing.
-            glVertexBindingDivisor(index, 0);
+            glVertexArrayBindingDivisor(vao, index, 0);
         }
     }
 
-    // Implicit set by glBindVertexBuffer. Stupid glstate handling...
-    state.draw.vertex_buffer = buffer_cache.GetHandle();
-
     gpu.dirty_flags.vertex_array = 0;
 }
 
@@ -293,7 +295,7 @@ DrawParameters RasterizerOpenGL::SetupDraw() {
 
 void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
     MICROPROFILE_SCOPE(OpenGL_Shader);
-    const auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
+    auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
 
     // Next available bindpoints to use when uploading the const buffers and textures to the GLSL
     // shaders. The constbuffer bindpoint starts after the shader stage configuration bind points.
@@ -365,7 +367,7 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
         // (sometimes it's half the screen, sometimes three quarters). To avoid this, enable the
         // clip distances only when it's written by a shader stage.
         for (std::size_t i = 0; i < Maxwell::NumClipDistances; ++i) {
-            clip_distances[i] |= shader->GetShaderEntries().clip_distances[i];
+            clip_distances[i] = clip_distances[i] || shader->GetShaderEntries().clip_distances[i];
         }
 
         // When VertexA is enabled, we have dual vertex shaders
@@ -376,6 +378,8 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
     }
 
     SyncClipEnabled(clip_distances);
+
+    gpu.dirty_flags.shaders = false;
 }
 
 void RasterizerOpenGL::SetupCachedFramebuffer(const FramebufferCacheKey& fbkey,
@@ -486,17 +490,26 @@ void RasterizerOpenGL::ConfigureFramebuffers(OpenGLState& current_state, bool us
                                              bool using_depth_fb, bool preserve_contents,
                                              std::optional<std::size_t> single_color_target) {
     MICROPROFILE_SCOPE(OpenGL_Framebuffer);
-    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+    const auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
+    const auto& regs = gpu.regs;
+
+    const FramebufferConfigState fb_config_state{using_color_fb, using_depth_fb, preserve_contents,
+                                                 single_color_target};
+    if (fb_config_state == current_framebuffer_config_state && gpu.dirty_flags.color_buffer == 0 &&
+        !gpu.dirty_flags.zeta_buffer) {
+        // Only skip if the previous ConfigureFramebuffers call was from the same kind (multiple or
+        // single color targets). This is done because the guest registers may not change but the
+        // host framebuffer may contain different attachments
+        return;
+    }
+    current_framebuffer_config_state = fb_config_state;
 
     Surface depth_surface;
     if (using_depth_fb) {
         depth_surface = res_cache.GetDepthBufferSurface(preserve_contents);
     }
 
-    // TODO(bunnei): Figure out how the below register works. According to envytools, this should be
-    // used to enable multiple render targets. However, it is left unset on all games that I have
-    // tested.
-    UNIMPLEMENTED_IF(regs.rt_separate_frag_data != 0);
+    UNIMPLEMENTED_IF(regs.rt_separate_frag_data == 0);
 
     // Bind the framebuffer surfaces
     current_state.framebuffer_srgb.enabled = regs.framebuffer_srgb != 0;
@@ -689,9 +702,6 @@ void RasterizerOpenGL::DrawArrays() {
     // Draw the vertex batch
     const bool is_indexed = accelerate_draw == AccelDraw::Indexed;
 
-    state.draw.vertex_buffer = buffer_cache.GetHandle();
-    state.ApplyVertexBufferState();
-
     std::size_t buffer_size = CalculateVertexArraysSize();
 
     // Add space for index buffer (keeping in mind non-core primitives)
@@ -721,8 +731,9 @@ void RasterizerOpenGL::DrawArrays() {
         gpu.dirty_flags.vertex_array = 0xFFFFFFFF;
     }
 
-    SetupVertexFormat();
-    SetupVertexBuffer();
+    const GLuint vao = SetupVertexFormat();
+    SetupVertexBuffer(vao);
+
     DrawParameters params = SetupDraw();
     SetupShaders(params.primitive_mode);
 
@@ -761,6 +772,7 @@ void RasterizerOpenGL::InvalidateRegion(VAddr addr, u64 size) {
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
     res_cache.InvalidateRegion(addr, size);
     shader_cache.InvalidateRegion(addr, size);
+    global_cache.InvalidateRegion(addr, size);
     buffer_cache.InvalidateRegion(addr, size);
 }
 
@@ -1014,8 +1026,11 @@ u32 RasterizerOpenGL::SetupTextures(Maxwell::ShaderStage stage, Shader& shader,
         texture_samplers[current_bindpoint].SyncWithConfig(texture.tsc);
         Surface surface = res_cache.GetTextureSurface(texture, entry);
         if (surface != nullptr) {
-            state.texture_units[current_bindpoint].texture = surface->Texture().handle;
-            state.texture_units[current_bindpoint].target = surface->Target();
+            const GLuint handle =
+                entry.IsArray() ? surface->TextureLayer().handle : surface->Texture().handle;
+            const GLenum target = entry.IsArray() ? surface->TargetLayer() : surface->Target();
+            state.texture_units[current_bindpoint].texture = handle;
+            state.texture_units[current_bindpoint].target = target;
             state.texture_units[current_bindpoint].swizzle.r =
                 MaxwellToGL::SwizzleSource(texture.tic.x_source);
             state.texture_units[current_bindpoint].swizzle.g =

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -23,6 +23,7 @@
 #include "video_core/rasterizer_cache.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_opengl/gl_buffer_cache.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"
@@ -66,6 +67,10 @@ public:
     static_assert(MaxConstbufferSize % sizeof(GLvec4) == 0,
                   "The maximum size of a constbuffer must be a multiple of the size of GLvec4");
 
+    static constexpr std::size_t MaxGlobalMemorySize = 0x10000;
+    static_assert(MaxGlobalMemorySize % sizeof(float) == 0,
+                  "The maximum size of a global memory must be a multiple of the size of float");
+
 private:
     class SamplerInfo {
     public:
@@ -94,6 +99,23 @@ private:
         float max_anisotropic = 1.0f;
     };
 
+    struct FramebufferConfigState {
+        bool using_color_fb{};
+        bool using_depth_fb{};
+        bool preserve_contents{};
+        std::optional<std::size_t> single_color_target;
+
+        bool operator==(const FramebufferConfigState& rhs) const {
+            return std::tie(using_color_fb, using_depth_fb, preserve_contents,
+                            single_color_target) == std::tie(rhs.using_color_fb, rhs.using_depth_fb,
+                                                             rhs.preserve_contents,
+                                                             rhs.single_color_target);
+        }
+        bool operator!=(const FramebufferConfigState& rhs) const {
+            return !operator==(rhs);
+        }
+    };
+
     /**
      * Configures the color and depth framebuffer states.
      * @param use_color_fb If true, configure color framebuffers.
@@ -105,7 +127,7 @@ private:
                                bool using_depth_fb = true, bool preserve_contents = true,
                                std::optional<std::size_t> single_color_target = {});
 
-    /*
+    /**
      * Configures the current constbuffers to use for the draw command.
      * @param stage The shader stage to configure buffers for.
      * @param shader The shader object that contains the specified stage.
@@ -115,7 +137,7 @@ private:
     u32 SetupConstBuffers(Tegra::Engines::Maxwell3D::Regs::ShaderStage stage, Shader& shader,
                           GLenum primitive_mode, u32 current_bindpoint);
 
-    /*
+    /**
      * Configures the current textures to use for the draw command.
      * @param stage The shader stage to configure textures for.
      * @param shader The shader object that contains the specified stage.
@@ -185,6 +207,7 @@ private:
 
     RasterizerCacheOpenGL res_cache;
     ShaderCacheOpenGL shader_cache;
+    GlobalRegionCacheOpenGL global_cache;
 
     Core::Frontend::EmuWindow& emu_window;
 
@@ -197,6 +220,7 @@ private:
         vertex_array_cache;
 
     std::map<FramebufferCacheKey, OGLFramebuffer> framebuffer_cache;
+    FramebufferConfigState current_framebuffer_config_state;
 
     std::array<SamplerInfo, Tegra::Engines::Maxwell3D::Regs::NumTextureSamplers> texture_samplers;
 
@@ -209,8 +233,10 @@ private:
 
     std::size_t CalculateIndexBufferSize() const;
 
-    void SetupVertexFormat();
-    void SetupVertexBuffer();
+    /// Updates and returns a vertex array object representing current vertex format
+    GLuint SetupVertexFormat();
+
+    void SetupVertexBuffer(GLuint vao);
 
     DrawParameters SetupDraw();
 

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -44,6 +44,17 @@ struct FormatTuple {
     bool compressed;
 };
 
+static void ApplyTextureDefaults(GLenum target, u32 max_mip_level) {
+    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, max_mip_level - 1);
+    if (max_mip_level == 1) {
+        glTexParameterf(target, GL_TEXTURE_LOD_BIAS, 1000.0);
+    }
+}
+
 void SurfaceParams::InitCacheParameters(Tegra::GPUVAddr gpu_addr_) {
     auto& memory_manager{Core::System::GetInstance().GPU().MemoryManager()};
     const auto cpu_addr{memory_manager.GpuToCpuAddress(gpu_addr_)};
@@ -441,7 +452,7 @@ static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
     const std::size_t buffer_size = std::max(src_params.size_in_bytes, dst_params.size_in_bytes);
 
     glBindBuffer(GL_PIXEL_PACK_BUFFER, copy_pbo_handle);
-    glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW);
+    glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_COPY);
     if (source_format.compressed) {
         glGetCompressedTextureImage(src_surface->Texture().handle, src_attachment,
                                     static_cast<GLsizei>(src_params.size_in_bytes), nullptr);
@@ -530,6 +541,9 @@ CachedSurface::CachedSurface(const SurfaceParams& params)
     glActiveTexture(GL_TEXTURE0);
 
     const auto& format_tuple = GetFormatTuple(params.pixel_format, params.component_type);
+    gl_internal_format = format_tuple.internal_format;
+    gl_is_compressed = format_tuple.compressed;
+
     if (!format_tuple.compressed) {
         // Only pre-create the texture for non-compressed textures.
         switch (params.target) {
@@ -558,15 +572,7 @@ CachedSurface::CachedSurface(const SurfaceParams& params)
         }
     }
 
-    glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_MAX_LEVEL,
-                    params.max_mip_level - 1);
-    if (params.max_mip_level == 1) {
-        glTexParameterf(SurfaceTargetToGL(params.target), GL_TEXTURE_LOD_BIAS, 1000.0);
-    }
+    ApplyTextureDefaults(SurfaceTargetToGL(params.target), params.max_mip_level);
 
     LabelGLObject(GL_TEXTURE, texture.handle, params.addr,
                   SurfaceParams::SurfaceTargetName(params.target));
@@ -864,6 +870,31 @@ void CachedSurface::UploadGLMipmapTexture(u32 mip_map, GLuint read_fb_handle,
     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 }
 
+void CachedSurface::EnsureTextureView() {
+    if (texture_view.handle != 0)
+        return;
+    // Compressed texture are not being created with immutable storage
+    UNIMPLEMENTED_IF(gl_is_compressed);
+
+    const GLenum target{TargetLayer()};
+
+    texture_view.Create();
+    glTextureView(texture_view.handle, target, texture.handle, gl_internal_format, 0,
+                  params.max_mip_level, 0, 1);
+
+    OpenGLState cur_state = OpenGLState::GetCurState();
+    const auto& old_tex = cur_state.texture_units[0];
+    SCOPE_EXIT({
+        cur_state.texture_units[0] = old_tex;
+        cur_state.Apply();
+    });
+    cur_state.texture_units[0].texture = texture_view.handle;
+    cur_state.texture_units[0].target = target;
+    cur_state.Apply();
+
+    ApplyTextureDefaults(target, params.max_mip_level);
+}
+
 MICROPROFILE_DEFINE(OpenGL_TextureUL, "OpenGL", "Texture Upload", MP_RGB(128, 192, 64));
 void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle) {
     if (params.type == SurfaceType::Fill)
@@ -888,9 +919,16 @@ Surface RasterizerCacheOpenGL::GetTextureSurface(const Tegra::Texture::FullTextu
 }
 
 Surface RasterizerCacheOpenGL::GetDepthBufferSurface(bool preserve_contents) {
-    const auto& regs{Core::System::GetInstance().GPU().Maxwell3D().regs};
+    auto& gpu{Core::System::GetInstance().GPU().Maxwell3D()};
+    const auto& regs{gpu.regs};
+
+    if (!gpu.dirty_flags.zeta_buffer) {
+        return last_depth_buffer;
+    }
+    gpu.dirty_flags.zeta_buffer = false;
+
     if (!regs.zeta.Address() || !regs.zeta_enable) {
-        return {};
+        return last_depth_buffer = {};
     }
 
     SurfaceParams depth_params{SurfaceParams::CreateForDepthBuffer(
@@ -898,25 +936,31 @@ Surface RasterizerCacheOpenGL::GetDepthBufferSurface(bool preserve_contents) {
         regs.zeta.memory_layout.block_width, regs.zeta.memory_layout.block_height,
         regs.zeta.memory_layout.block_depth, regs.zeta.memory_layout.type)};
 
-    return GetSurface(depth_params, preserve_contents);
+    return last_depth_buffer = GetSurface(depth_params, preserve_contents);
 }
 
 Surface RasterizerCacheOpenGL::GetColorBufferSurface(std::size_t index, bool preserve_contents) {
-    const auto& regs{Core::System::GetInstance().GPU().Maxwell3D().regs};
+    auto& gpu{Core::System::GetInstance().GPU().Maxwell3D()};
+    const auto& regs{gpu.regs};
+
+    if ((gpu.dirty_flags.color_buffer & (1u << static_cast<u32>(index))) == 0) {
+        return last_color_buffers[index];
+    }
+    gpu.dirty_flags.color_buffer &= ~(1u << static_cast<u32>(index));
 
     ASSERT(index < Tegra::Engines::Maxwell3D::Regs::NumRenderTargets);
 
     if (index >= regs.rt_control.count) {
-        return {};
+        return last_color_buffers[index] = {};
     }
 
     if (regs.rt[index].Address() == 0 || regs.rt[index].format == Tegra::RenderTargetFormat::NONE) {
-        return {};
+        return last_color_buffers[index] = {};
     }
 
     const SurfaceParams color_params{SurfaceParams::CreateForFramebuffer(index)};
 
-    return GetSurface(color_params, preserve_contents);
+    return last_color_buffers[index] = GetSurface(color_params, preserve_contents);
 }
 
 void RasterizerCacheOpenGL::LoadSurface(const Surface& surface) {

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -293,10 +293,31 @@ public:
         return texture;
     }
 
+    const OGLTexture& TextureLayer() {
+        if (params.is_layered) {
+            return Texture();
+        }
+        EnsureTextureView();
+        return texture_view;
+    }
+
     GLenum Target() const {
         return gl_target;
     }
 
+    GLenum TargetLayer() const {
+        using VideoCore::Surface::SurfaceTarget;
+        switch (params.target) {
+        case SurfaceTarget::Texture1D:
+            return GL_TEXTURE_1D_ARRAY;
+        case SurfaceTarget::Texture2D:
+            return GL_TEXTURE_2D_ARRAY;
+        case SurfaceTarget::TextureCubemap:
+            return GL_TEXTURE_CUBE_MAP_ARRAY;
+        }
+        return Target();
+    }
+
     const SurfaceParams& GetSurfaceParams() const {
         return params;
     }
@@ -311,11 +332,16 @@ public:
 private:
     void UploadGLMipmapTexture(u32 mip_map, GLuint read_fb_handle, GLuint draw_fb_handle);
 
+    void EnsureTextureView();
+
     OGLTexture texture;
+    OGLTexture texture_view;
     std::vector<std::vector<u8>> gl_buffer;
-    SurfaceParams params;
-    GLenum gl_target;
-    std::size_t cached_size_in_bytes;
+    SurfaceParams params{};
+    GLenum gl_target{};
+    GLenum gl_internal_format{};
+    bool gl_is_compressed{};
+    std::size_t cached_size_in_bytes{};
 };
 
 class RasterizerCacheOpenGL final : public RasterizerCache<Surface> {
@@ -370,6 +396,9 @@ private:
     /// Use a Pixel Buffer Object to download the previous texture and then upload it to the new one
     /// using the new format.
     OGLBuffer copy_pbo;
+
+    std::array<Surface, Tegra::Engines::Maxwell3D::Regs::NumRenderTargets> last_color_buffers;
+    Surface last_depth_buffer;
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_resource_manager.cpp

@@ -117,7 +117,7 @@ void OGLBuffer::Create() {
         return;
 
     MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    glGenBuffers(1, &handle);
+    glCreateBuffers(1, &handle);
 }
 
 void OGLBuffer::Release() {
@@ -126,7 +126,6 @@ void OGLBuffer::Release() {
 
     MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteBuffers(1, &handle);
-    OpenGLState::GetCurState().ResetBuffer(handle).Apply();
     handle = 0;
 }
 
@@ -152,7 +151,7 @@ void OGLVertexArray::Create() {
         return;
 
     MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    glGenVertexArrays(1, &handle);
+    glCreateVertexArrays(1, &handle);
 }
 
 void OGLVertexArray::Release() {

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -188,6 +188,10 @@ void CachedShader::CalculateProperties() {
 ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer) : RasterizerCache{rasterizer} {}
 
 Shader ShaderCacheOpenGL::GetStageProgram(Maxwell::ShaderProgram program) {
+    if (!Core::System::GetInstance().GPU().Maxwell3D().dirty_flags.shaders) {
+        return last_shaders[static_cast<u32>(program)];
+    }
+
     const VAddr program_addr{GetShaderAddress(program)};
 
     // Look up shader in the cache based on address
@@ -199,7 +203,7 @@ Shader ShaderCacheOpenGL::GetStageProgram(Maxwell::ShaderProgram program) {
         Register(shader);
     }
 
-    return shader;
+    return last_shaders[static_cast<u32>(program)] = shader;
 }
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <array>
 #include <map>
 #include <memory>
 
@@ -115,6 +116,9 @@ public:
 
     /// Gets the current specified shader stage program
     Shader GetStageProgram(Maxwell::ShaderProgram program);
+
+private:
+    std::array<Shader, Maxwell::MaxShaderProgram> last_shaders;
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_state.cpp

@@ -83,8 +83,6 @@ OpenGLState::OpenGLState() {
     draw.read_framebuffer = 0;
     draw.draw_framebuffer = 0;
     draw.vertex_array = 0;
-    draw.vertex_buffer = 0;
-    draw.uniform_buffer = 0;
     draw.shader_program = 0;
     draw.program_pipeline = 0;
 
@@ -505,7 +503,6 @@ void OpenGLState::ApplySamplers() const {
 }
 
 void OpenGLState::ApplyFramebufferState() const {
-    // Framebuffer
     if (draw.read_framebuffer != cur_state.draw.read_framebuffer) {
         glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
     }
@@ -514,16 +511,10 @@ void OpenGLState::ApplyFramebufferState() const {
     }
 }
 
-void OpenGLState::ApplyVertexBufferState() const {
-    // Vertex array
+void OpenGLState::ApplyVertexArrayState() const {
     if (draw.vertex_array != cur_state.draw.vertex_array) {
         glBindVertexArray(draw.vertex_array);
     }
-
-    // Vertex buffer
-    if (draw.vertex_buffer != cur_state.draw.vertex_buffer) {
-        glBindBuffer(GL_ARRAY_BUFFER, draw.vertex_buffer);
-    }
 }
 
 void OpenGLState::ApplyDepthClamp() const {
@@ -543,11 +534,7 @@ void OpenGLState::ApplyDepthClamp() const {
 
 void OpenGLState::Apply() const {
     ApplyFramebufferState();
-    ApplyVertexBufferState();
-    // Uniform buffer
-    if (draw.uniform_buffer != cur_state.draw.uniform_buffer) {
-        glBindBuffer(GL_UNIFORM_BUFFER, draw.uniform_buffer);
-    }
+    ApplyVertexArrayState();
 
     // Shader program
     if (draw.shader_program != cur_state.draw.shader_program) {
@@ -638,16 +625,6 @@ OpenGLState& OpenGLState::ResetPipeline(GLuint handle) {
     return *this;
 }
 
-OpenGLState& OpenGLState::ResetBuffer(GLuint handle) {
-    if (draw.vertex_buffer == handle) {
-        draw.vertex_buffer = 0;
-    }
-    if (draw.uniform_buffer == handle) {
-        draw.uniform_buffer = 0;
-    }
-    return *this;
-}
-
 OpenGLState& OpenGLState::ResetVertexArray(GLuint handle) {
     if (draw.vertex_array == handle) {
         draw.vertex_array = 0;

src/video_core/renderer_opengl/gl_state.h

@@ -154,8 +154,6 @@ public:
         GLuint read_framebuffer; // GL_READ_FRAMEBUFFER_BINDING
         GLuint draw_framebuffer; // GL_DRAW_FRAMEBUFFER_BINDING
         GLuint vertex_array;     // GL_VERTEX_ARRAY_BINDING
-        GLuint vertex_buffer;    // GL_ARRAY_BUFFER_BINDING
-        GLuint uniform_buffer;   // GL_UNIFORM_BUFFER_BINDING
         GLuint shader_program;   // GL_CURRENT_PROGRAM
         GLuint program_pipeline; // GL_PROGRAM_PIPELINE_BINDING
     } draw;
@@ -206,10 +204,10 @@ public:
     }
     /// Apply this state as the current OpenGL state
     void Apply() const;
-    /// Apply only the state afecting the framebuffer
+    /// Apply only the state affecting the framebuffer
     void ApplyFramebufferState() const;
-    /// Apply only the state afecting the vertex buffer
-    void ApplyVertexBufferState() const;
+    /// Apply only the state affecting the vertex array
+    void ApplyVertexArrayState() const;
     /// Set the initial OpenGL state
     static void ApplyDefaultState();
     /// Resets any references to the given resource
@@ -217,7 +215,6 @@ public:
     OpenGLState& ResetSampler(GLuint handle);
     OpenGLState& ResetProgram(GLuint handle);
     OpenGLState& ResetPipeline(GLuint handle);
-    OpenGLState& ResetBuffer(GLuint handle);
     OpenGLState& ResetVertexArray(GLuint handle);
     OpenGLState& ResetFramebuffer(GLuint handle);
     void EmulateViewportWithScissor();

src/video_core/renderer_opengl/gl_stream_buffer.cpp

@@ -15,13 +15,12 @@ MICROPROFILE_DEFINE(OpenGL_StreamBuffer, "OpenGL", "Stream Buffer Orphaning",
 
 namespace OpenGL {
 
-OGLStreamBuffer::OGLStreamBuffer(GLenum target, GLsizeiptr size, bool prefer_coherent)
-    : gl_target(target), buffer_size(size) {
+OGLStreamBuffer::OGLStreamBuffer(GLsizeiptr size, bool vertex_data_usage, bool prefer_coherent)
+    : buffer_size(size) {
     gl_buffer.Create();
-    glBindBuffer(gl_target, gl_buffer.handle);
 
     GLsizeiptr allocate_size = size;
-    if (target == GL_ARRAY_BUFFER) {
+    if (vertex_data_usage) {
         // On AMD GPU there is a strange crash in indexed drawing. The crash happens when the buffer
         // read position is near the end and is an out-of-bound access to the vertex buffer. This is
         // probably a bug in the driver and is related to the usage of vec3<byte> attributes in the
@@ -35,18 +34,17 @@ OGLStreamBuffer::OGLStreamBuffer(GLenum target, GLsizeiptr size, bool prefer_coh
         coherent = prefer_coherent;
         const GLbitfield flags =
             GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | (coherent ? GL_MAP_COHERENT_BIT : 0);
-        glBufferStorage(gl_target, allocate_size, nullptr, flags);
-        mapped_ptr = static_cast<u8*>(glMapBufferRange(
-            gl_target, 0, buffer_size, flags | (coherent ? 0 : GL_MAP_FLUSH_EXPLICIT_BIT)));
+        glNamedBufferStorage(gl_buffer.handle, allocate_size, nullptr, flags);
+        mapped_ptr = static_cast<u8*>(glMapNamedBufferRange(
+            gl_buffer.handle, 0, buffer_size, flags | (coherent ? 0 : GL_MAP_FLUSH_EXPLICIT_BIT)));
     } else {
-        glBufferData(gl_target, allocate_size, nullptr, GL_STREAM_DRAW);
+        glNamedBufferData(gl_buffer.handle, allocate_size, nullptr, GL_STREAM_DRAW);
     }
 }
 
 OGLStreamBuffer::~OGLStreamBuffer() {
     if (persistent) {
-        glBindBuffer(gl_target, gl_buffer.handle);
-        glUnmapBuffer(gl_target);
+        glUnmapNamedBuffer(gl_buffer.handle);
     }
     gl_buffer.Release();
 }
@@ -74,7 +72,7 @@ std::tuple<u8*, GLintptr, bool> OGLStreamBuffer::Map(GLsizeiptr size, GLintptr a
         invalidate = true;
 
         if (persistent) {
-            glUnmapBuffer(gl_target);
+            glUnmapNamedBuffer(gl_buffer.handle);
         }
     }
 
@@ -84,7 +82,7 @@ std::tuple<u8*, GLintptr, bool> OGLStreamBuffer::Map(GLsizeiptr size, GLintptr a
                            (coherent ? GL_MAP_COHERENT_BIT : GL_MAP_FLUSH_EXPLICIT_BIT) |
                            (invalidate ? GL_MAP_INVALIDATE_BUFFER_BIT : GL_MAP_UNSYNCHRONIZED_BIT);
         mapped_ptr = static_cast<u8*>(
-            glMapBufferRange(gl_target, buffer_pos, buffer_size - buffer_pos, flags));
+            glMapNamedBufferRange(gl_buffer.handle, buffer_pos, buffer_size - buffer_pos, flags));
         mapped_offset = buffer_pos;
     }
 
@@ -95,11 +93,11 @@ void OGLStreamBuffer::Unmap(GLsizeiptr size) {
     ASSERT(size <= mapped_size);
 
     if (!coherent && size > 0) {
-        glFlushMappedBufferRange(gl_target, buffer_pos - mapped_offset, size);
+        glFlushMappedNamedBufferRange(gl_buffer.handle, buffer_pos - mapped_offset, size);
     }
 
     if (!persistent) {
-        glUnmapBuffer(gl_target);
+        glUnmapNamedBuffer(gl_buffer.handle);
     }
 
     buffer_pos += size;

src/video_core/renderer_opengl/gl_stream_buffer.h

@@ -13,7 +13,7 @@ namespace OpenGL {
 
 class OGLStreamBuffer : private NonCopyable {
 public:
-    explicit OGLStreamBuffer(GLenum target, GLsizeiptr size, bool prefer_coherent = false);
+    explicit OGLStreamBuffer(GLsizeiptr size, bool vertex_data_usage, bool prefer_coherent = false);
     ~OGLStreamBuffer();
 
     GLuint GetHandle() const;
@@ -33,7 +33,6 @@ public:
 
 private:
     OGLBuffer gl_buffer;
-    GLenum gl_target;
 
     bool coherent = false;
     bool persistent = false;

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -245,20 +245,20 @@ void RendererOpenGL::InitOpenGLObjects() {
 
     // Generate VAO
     vertex_array.Create();
-
     state.draw.vertex_array = vertex_array.handle;
-    state.draw.vertex_buffer = vertex_buffer.handle;
-    state.draw.uniform_buffer = 0;
-    state.Apply();
 
     // Attach vertex data to VAO
-    glBufferData(GL_ARRAY_BUFFER, sizeof(ScreenRectVertex) * 4, nullptr, GL_STREAM_DRAW);
-    glVertexAttribPointer(attrib_position, 2, GL_FLOAT, GL_FALSE, sizeof(ScreenRectVertex),
-                          (GLvoid*)offsetof(ScreenRectVertex, position));
-    glVertexAttribPointer(attrib_tex_coord, 2, GL_FLOAT, GL_FALSE, sizeof(ScreenRectVertex),
-                          (GLvoid*)offsetof(ScreenRectVertex, tex_coord));
-    glEnableVertexAttribArray(attrib_position);
-    glEnableVertexAttribArray(attrib_tex_coord);
+    glNamedBufferData(vertex_buffer.handle, sizeof(ScreenRectVertex) * 4, nullptr, GL_STREAM_DRAW);
+    glVertexArrayAttribFormat(vertex_array.handle, attrib_position, 2, GL_FLOAT, GL_FALSE,
+                              offsetof(ScreenRectVertex, position));
+    glVertexArrayAttribFormat(vertex_array.handle, attrib_tex_coord, 2, GL_FLOAT, GL_FALSE,
+                              offsetof(ScreenRectVertex, tex_coord));
+    glVertexArrayAttribBinding(vertex_array.handle, attrib_position, 0);
+    glVertexArrayAttribBinding(vertex_array.handle, attrib_tex_coord, 0);
+    glEnableVertexArrayAttrib(vertex_array.handle, attrib_position);
+    glEnableVertexArrayAttrib(vertex_array.handle, attrib_tex_coord);
+    glVertexArrayVertexBuffer(vertex_array.handle, 0, vertex_buffer.handle, 0,
+                              sizeof(ScreenRectVertex));
 
     // Allocate textures for the screen
     screen_info.texture.resource.Create();
@@ -370,14 +370,12 @@ void RendererOpenGL::DrawScreenTriangles(const ScreenInfo& screen_info, float x,
     state.texture_units[0].texture = screen_info.display_texture;
     state.texture_units[0].swizzle = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA};
     // Workaround brigthness problems in SMO by enabling sRGB in the final output
-    // if it has been used in the frame
-    // Needed because of this bug in QT
-    // QTBUG-50987
+    // if it has been used in the frame. Needed because of this bug in QT: QTBUG-50987
     state.framebuffer_srgb.enabled = OpenGLState::GetsRGBUsed();
     state.Apply();
-    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices.data());
+    glNamedBufferSubData(vertex_buffer.handle, 0, sizeof(vertices), vertices.data());
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-    // restore default state
+    // Restore default state
     state.framebuffer_srgb.enabled = false;
     state.texture_units[0].texture = 0;
     state.Apply();

src/yuzu/CMakeLists.txt

@@ -11,6 +11,8 @@ add_executable(yuzu
     applets/profile_select.h
     applets/software_keyboard.cpp
     applets/software_keyboard.h
+    applets/web_browser.cpp
+    applets/web_browser.h
     bootmanager.cpp
     bootmanager.h
     compatibility_list.cpp
@@ -37,6 +39,8 @@ add_executable(yuzu
     configuration/configure_input_simple.h
     configuration/configure_mouse_advanced.cpp
     configuration/configure_mouse_advanced.h
+    configuration/configure_profile_manager.cpp
+    configuration/configure_profile_manager.h
     configuration/configure_system.cpp
     configuration/configure_system.h
     configuration/configure_per_general.cpp
@@ -64,6 +68,8 @@ add_executable(yuzu
     game_list_p.h
     game_list_worker.cpp
     game_list_worker.h
+    loading_screen.cpp
+    loading_screen.h
     hotkeys.cpp
     hotkeys.h
     main.cpp
@@ -94,12 +100,14 @@ set(UIS
     configuration/configure_input_simple.ui
     configuration/configure_mouse_advanced.ui
     configuration/configure_per_general.ui
+    configuration/configure_profile_manager.ui
     configuration/configure_system.ui
     configuration/configure_touchscreen_advanced.ui
     configuration/configure_web.ui
-    hotkeys.ui
-    main.ui
     compatdb.ui
+    hotkeys.ui
+    loading_screen.ui
+    main.ui
 )
 
 file(GLOB COMPAT_LIST
@@ -154,6 +162,11 @@ if (USE_DISCORD_PRESENCE)
     target_compile_definitions(yuzu PRIVATE -DUSE_DISCORD_PRESENCE)
 endif()
 
+if (YUZU_USE_QT_WEB_ENGINE)
+    target_link_libraries(yuzu PRIVATE Qt5::WebEngineCore Qt5::WebEngineWidgets)
+    target_compile_definitions(yuzu PRIVATE -DYUZU_USE_QT_WEB_ENGINE)
+endif ()
+
 if(UNIX AND NOT APPLE)
     install(TARGETS yuzu RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
 endif()

src/yuzu/applets/web_browser.cpp

@@ -0,0 +1,113 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <mutex>
+
+#include <QKeyEvent>
+
+#include "core/hle/lock.h"
+#include "yuzu/applets/web_browser.h"
+#include "yuzu/main.h"
+
+#ifdef YUZU_USE_QT_WEB_ENGINE
+
+constexpr char NX_SHIM_INJECT_SCRIPT[] = R"(
+    window.nx = {};
+    window.nx.playReport = {};
+    window.nx.playReport.setCounterSetIdentifier = function () {
+        console.log("nx.playReport.setCounterSetIdentifier called - unimplemented");
+    };
+
+    window.nx.playReport.incrementCounter = function () {
+        console.log("nx.playReport.incrementCounter called - unimplemented");
+    };
+
+    window.nx.footer = {};
+    window.nx.footer.unsetAssign = function () {
+        console.log("nx.footer.unsetAssign called - unimplemented");
+    };
+
+    var yuzu_key_callbacks = [];
+    window.nx.footer.setAssign = function(key, discard1, func, discard2) {
+        switch (key) {
+        case 'A':
+            yuzu_key_callbacks[0] = func;
+            break;
+        case 'B':
+            yuzu_key_callbacks[1] = func;
+            break;
+        case 'X':
+            yuzu_key_callbacks[2] = func;
+            break;
+        case 'Y':
+            yuzu_key_callbacks[3] = func;
+            break;
+        case 'L':
+            yuzu_key_callbacks[6] = func;
+            break;
+        case 'R':
+            yuzu_key_callbacks[7] = func;
+            break;
+        }
+    };
+
+    var applet_done = false;
+    window.nx.endApplet = function() {
+        applet_done = true;
+    };
+)";
+
+QString GetNXShimInjectionScript() {
+    return QString::fromStdString(NX_SHIM_INJECT_SCRIPT);
+}
+
+NXInputWebEngineView::NXInputWebEngineView(QWidget* parent) : QWebEngineView(parent) {}
+
+void NXInputWebEngineView::keyPressEvent(QKeyEvent* event) {
+    parent()->event(event);
+}
+
+void NXInputWebEngineView::keyReleaseEvent(QKeyEvent* event) {
+    parent()->event(event);
+}
+
+#endif
+
+QtWebBrowser::QtWebBrowser(GMainWindow& main_window) {
+    connect(this, &QtWebBrowser::MainWindowOpenPage, &main_window, &GMainWindow::WebBrowserOpenPage,
+            Qt::QueuedConnection);
+    connect(&main_window, &GMainWindow::WebBrowserUnpackRomFS, this,
+            &QtWebBrowser::MainWindowUnpackRomFS, Qt::QueuedConnection);
+    connect(&main_window, &GMainWindow::WebBrowserFinishedBrowsing, this,
+            &QtWebBrowser::MainWindowFinishedBrowsing, Qt::QueuedConnection);
+}
+
+QtWebBrowser::~QtWebBrowser() = default;
+
+void QtWebBrowser::OpenPage(std::string_view url, std::function<void()> unpack_romfs_callback,
+                            std::function<void()> finished_callback) {
+    this->unpack_romfs_callback = std::move(unpack_romfs_callback);
+    this->finished_callback = std::move(finished_callback);
+
+    const auto index = url.find('?');
+    if (index == std::string::npos) {
+        emit MainWindowOpenPage(url, "");
+    } else {
+        const auto front = url.substr(0, index);
+        const auto back = url.substr(index);
+        emit MainWindowOpenPage(front, back);
+    }
+}
+
+void QtWebBrowser::MainWindowUnpackRomFS() {
+    // Acquire the HLE mutex
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+    unpack_romfs_callback();
+}
+
+void QtWebBrowser::MainWindowFinishedBrowsing() {
+    // Acquire the HLE mutex
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+    finished_callback();
+}

src/yuzu/applets/web_browser.h

@@ -0,0 +1,52 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <QObject>
+
+#ifdef YUZU_USE_QT_WEB_ENGINE
+#include <QWebEngineView>
+#endif
+
+#include "core/frontend/applets/web_browser.h"
+
+class GMainWindow;
+
+#ifdef YUZU_USE_QT_WEB_ENGINE
+
+QString GetNXShimInjectionScript();
+
+class NXInputWebEngineView : public QWebEngineView {
+public:
+    explicit NXInputWebEngineView(QWidget* parent = nullptr);
+
+protected:
+    void keyPressEvent(QKeyEvent* event) override;
+    void keyReleaseEvent(QKeyEvent* event) override;
+};
+
+#endif
+
+class QtWebBrowser final : public QObject, public Core::Frontend::WebBrowserApplet {
+    Q_OBJECT
+
+public:
+    explicit QtWebBrowser(GMainWindow& main_window);
+    ~QtWebBrowser() override;
+
+    void OpenPage(std::string_view url, std::function<void()> unpack_romfs_callback,
+                  std::function<void()> finished_callback) override;
+
+signals:
+    void MainWindowOpenPage(std::string_view filename, std::string_view additional_args) const;
+
+private:
+    void MainWindowUnpackRomFS();
+    void MainWindowFinishedBrowsing();
+
+    std::function<void()> unpack_romfs_callback;
+    std::function<void()> finished_callback;
+};

src/yuzu/bootmanager.cpp

@@ -3,9 +3,7 @@
 #include <QKeyEvent>
 #include <QScreen>
 #include <QWindow>
-
 #include <fmt/format.h>
-
 #include "common/microprofile.h"
 #include "common/scm_rev.h"
 #include "core/core.h"
@@ -17,6 +15,7 @@
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 #include "yuzu/bootmanager.h"
+#include "yuzu/main.h"
 
 EmuThread::EmuThread(GRenderWindow* render_window) : render_window(render_window) {}
 
@@ -114,6 +113,8 @@ GRenderWindow::GRenderWindow(QWidget* parent, EmuThread* emu_thread)
 
     InputCommon::Init();
     InputCommon::StartJoystickEventHandler();
+    connect(this, &GRenderWindow::FirstFrameDisplayed, static_cast<GMainWindow*>(parent),
+            &GMainWindow::OnLoadComplete);
 }
 
 GRenderWindow::~GRenderWindow() {
@@ -141,6 +142,10 @@ void GRenderWindow::SwapBuffers() {
     child->makeCurrent();
 
     child->swapBuffers();
+    if (!first_frame) {
+        emit FirstFrameDisplayed();
+        first_frame = true;
+    }
 }
 
 void GRenderWindow::MakeCurrent() {
@@ -309,6 +314,8 @@ void GRenderWindow::InitRenderTarget() {
         delete layout();
     }
 
+    first_frame = false;
+
     // TODO: One of these flags might be interesting: WA_OpaquePaintEvent, WA_NoBackground,
     // WA_DontShowOnScreen, WA_DeleteOnClose
     QGLFormat fmt;

src/yuzu/bootmanager.h

@@ -152,6 +152,7 @@ public slots:
 signals:
     /// Emitted when the window is closed
     void Closed();
+    void FirstFrameDisplayed();
 
 private:
     std::pair<unsigned, unsigned> ScaleTouch(const QPointF pos) const;
@@ -171,6 +172,8 @@ private:
     /// Temporary storage of the screenshot taken
     QImage screenshot_image;
 
+    bool first_frame = false;
+
 protected:
     void showEvent(QShowEvent* event) override;
 };

src/yuzu/configuration/config.cpp

@@ -419,13 +419,21 @@ void Config::ReadValues() {
 
     Settings::values.language_index = qt_config->value("language_index", 1).toInt();
 
-    const auto enabled = qt_config->value("rng_seed_enabled", false).toBool();
-    if (enabled) {
+    const auto rng_seed_enabled = qt_config->value("rng_seed_enabled", false).toBool();
+    if (rng_seed_enabled) {
         Settings::values.rng_seed = qt_config->value("rng_seed", 0).toULongLong();
     } else {
         Settings::values.rng_seed = std::nullopt;
     }
 
+    const auto custom_rtc_enabled = qt_config->value("custom_rtc_enabled", false).toBool();
+    if (custom_rtc_enabled) {
+        Settings::values.custom_rtc =
+            std::chrono::seconds(qt_config->value("custom_rtc", 0).toULongLong());
+    } else {
+        Settings::values.custom_rtc = std::nullopt;
+    }
+
     qt_config->endGroup();
 
     qt_config->beginGroup("Miscellaneous");
@@ -470,6 +478,8 @@ void Config::ReadValues() {
         qt_config->value("enable_discord_presence", true).toBool();
     UISettings::values.screenshot_resolution_factor =
         static_cast<u16>(qt_config->value("screenshot_resolution_factor", 0).toUInt());
+    UISettings::values.select_user_on_boot =
+        qt_config->value("select_user_on_boot", false).toBool();
 
     qt_config->beginGroup("UIGameList");
     UISettings::values.show_unknown = qt_config->value("show_unknown", true).toBool();
@@ -651,6 +661,11 @@ void Config::SaveValues() {
     qt_config->setValue("rng_seed_enabled", Settings::values.rng_seed.has_value());
     qt_config->setValue("rng_seed", Settings::values.rng_seed.value_or(0));
 
+    qt_config->setValue("custom_rtc_enabled", Settings::values.custom_rtc.has_value());
+    qt_config->setValue("custom_rtc",
+                        QVariant::fromValue<long long>(
+                            Settings::values.custom_rtc.value_or(std::chrono::seconds{}).count()));
+
     qt_config->endGroup();
 
     qt_config->beginGroup("Miscellaneous");
@@ -680,7 +695,7 @@ void Config::SaveValues() {
         qt_config->setValue("title_id", QVariant::fromValue<u64>(elem.first));
         qt_config->beginWriteArray("disabled");
         for (std::size_t j = 0; j < elem.second.size(); ++j) {
-            qt_config->setArrayIndex(j);
+            qt_config->setArrayIndex(static_cast<int>(j));
             qt_config->setValue("d", QString::fromStdString(elem.second[j]));
         }
         qt_config->endArray();
@@ -693,6 +708,7 @@ void Config::SaveValues() {
     qt_config->setValue("enable_discord_presence", UISettings::values.enable_discord_presence);
     qt_config->setValue("screenshot_resolution_factor",
                         UISettings::values.screenshot_resolution_factor);
+    qt_config->setValue("select_user_on_boot", UISettings::values.select_user_on_boot);
 
     qt_config->beginGroup("UIGameList");
     qt_config->setValue("show_unknown", UISettings::values.show_unknown);

src/yuzu/configuration/configure.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>461</width>
-    <height>659</height>
+    <width>382</width>
+    <height>241</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -15,51 +15,76 @@
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
-    <widget class="QTabWidget" name="tabWidget">
-     <property name="currentIndex">
-      <number>0</number>
-     </property>
-     <widget class="ConfigureGeneral" name="generalTab">
-      <attribute name="title">
-       <string>General</string>
-      </attribute>
-     </widget>
-     <widget class="ConfigureGameList" name="gameListTab">
-      <attribute name="title">
-       <string>Game List</string>
-      </attribute>
-     </widget>
-     <widget class="ConfigureSystem" name="systemTab">
-      <attribute name="title">
-       <string>System</string>
-      </attribute>
-     </widget>
-     <widget class="ConfigureInputSimple" name="inputTab">
-      <attribute name="title">
-       <string>Input</string>
-      </attribute>
-     </widget>
-     <widget class="ConfigureGraphics" name="graphicsTab">
-      <attribute name="title">
-       <string>Graphics</string>
-      </attribute>
-     </widget>
-     <widget class="ConfigureAudio" name="audioTab">
-      <attribute name="title">
-       <string>Audio</string>
-      </attribute>
-     </widget>
-     <widget class="ConfigureDebug" name="debugTab">
-      <attribute name="title">
-       <string>Debug</string>
-      </attribute>
-     </widget>
-     <widget class="ConfigureWeb" name="webTab">
-      <attribute name="title">
-       <string>Web</string>
-      </attribute>
-     </widget>
-    </widget>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QListWidget" name="selectorList">
+       <property name="minimumSize">
+        <size>
+         <width>150</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="maximumSize">
+        <size>
+         <width>150</width>
+         <height>16777215</height>
+        </size>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QTabWidget" name="tabWidget">
+       <property name="currentIndex">
+        <number>0</number>
+       </property>
+       <widget class="ConfigureGeneral" name="generalTab">
+        <attribute name="title">
+         <string>General</string>
+        </attribute>
+       </widget>
+       <widget class="ConfigureGameList" name="gameListTab">
+        <attribute name="title">
+         <string>Game List</string>
+        </attribute>
+       </widget>
+       <widget class="ConfigureSystem" name="systemTab">
+        <attribute name="title">
+         <string>System</string>
+        </attribute>
+       </widget>
+       <widget class="ConfigureProfileManager" name="profileManagerTab">
+        <attribute name="title">
+         <string>Profiles</string>
+        </attribute>
+       </widget>
+       <widget class="ConfigureInputSimple" name="inputTab">
+        <attribute name="title">
+         <string>Input</string>
+        </attribute>
+       </widget>
+       <widget class="ConfigureGraphics" name="graphicsTab">
+        <attribute name="title">
+         <string>Graphics</string>
+        </attribute>
+       </widget>
+       <widget class="ConfigureAudio" name="audioTab">
+        <attribute name="title">
+         <string>Audio</string>
+        </attribute>
+       </widget>
+       <widget class="ConfigureDebug" name="debugTab">
+        <attribute name="title">
+         <string>Debug</string>
+        </attribute>
+       </widget>
+       <widget class="ConfigureWeb" name="webTab">
+        <attribute name="title">
+         <string>Web</string>
+        </attribute>
+       </widget>
+      </widget>
+     </item>
+    </layout>
    </item>
    <item>
     <widget class="QDialogButtonBox" name="buttonBox">
@@ -77,18 +102,18 @@
    <header>configuration/configure_general.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>ConfigureGameList</class>
-   <extends>QWidget</extends>
-   <header>configuration/configure_gamelist.h</header>
-   <container>1</container>
-  </customwidget>
   <customwidget>
    <class>ConfigureSystem</class>
    <extends>QWidget</extends>
    <header>configuration/configure_system.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>ConfigureProfileManager</class>
+   <extends>QWidget</extends>
+   <header>configuration/configure_profile_manager.h</header>
+   <container>1</container>
+  </customwidget>
   <customwidget>
    <class>ConfigureAudio</class>
    <extends>QWidget</extends>
@@ -101,12 +126,6 @@
    <header>configuration/configure_debug.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>ConfigureInputSimple</class>
-   <extends>QWidget</extends>
-   <header>configuration/configure_input_simple.h</header>
-   <container>1</container>
-  </customwidget>
   <customwidget>
    <class>ConfigureGraphics</class>
    <extends>QWidget</extends>
@@ -119,6 +138,18 @@
    <header>configuration/configure_web.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>ConfigureGameList</class>
+   <extends>QWidget</extends>
+   <header>configuration/configure_gamelist.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>ConfigureInputSimple</class>
+   <extends>QWidget</extends>
+   <header>configuration/configure_input_simple.h</header>
+   <container>1</container>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections>

src/yuzu/configuration/configure_debug.cpp

@@ -7,7 +7,6 @@
 #include "common/file_util.h"
 #include "common/logging/backend.h"
 #include "common/logging/filter.h"
-#include "common/logging/log.h"
 #include "core/core.h"
 #include "core/settings.h"
 #include "ui_configure_debug.h"

src/yuzu/configuration/configure_dialog.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <QHash>
+#include <QListWidgetItem>
 #include "core/settings.h"
 #include "ui_configure.h"
 #include "yuzu/configuration/config.h"
@@ -13,6 +15,13 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, const HotkeyRegistry& registry
     ui->setupUi(this);
     ui->generalTab->PopulateHotkeyList(registry);
     this->setConfiguration();
+    this->PopulateSelectionList();
+    connect(ui->selectorList, &QListWidget::itemSelectionChanged, this,
+            &ConfigureDialog::UpdateVisibleTabs);
+
+    adjustSize();
+
+    ui->selectorList->setCurrentRow(0);
 }
 
 ConfigureDialog::~ConfigureDialog() = default;
@@ -23,6 +32,7 @@ void ConfigureDialog::applyConfiguration() {
     ui->generalTab->applyConfiguration();
     ui->gameListTab->applyConfiguration();
     ui->systemTab->applyConfiguration();
+    ui->profileManagerTab->applyConfiguration();
     ui->inputTab->applyConfiguration();
     ui->graphicsTab->applyConfiguration();
     ui->audioTab->applyConfiguration();
@@ -30,3 +40,41 @@ void ConfigureDialog::applyConfiguration() {
     ui->webTab->applyConfiguration();
     Settings::Apply();
 }
+
+void ConfigureDialog::PopulateSelectionList() {
+    const std::array<std::pair<QString, QStringList>, 4> items{
+        {{tr("General"), {tr("General"), tr("Web"), tr("Debug"), tr("Game List")}},
+         {tr("System"), {tr("System"), tr("Profiles"), tr("Audio")}},
+         {tr("Graphics"), {tr("Graphics")}},
+         {tr("Controls"), {tr("Input")}}}};
+
+    for (const auto& entry : items) {
+        auto* const item = new QListWidgetItem(entry.first);
+        item->setData(Qt::UserRole, entry.second);
+
+        ui->selectorList->addItem(item);
+    }
+}
+
+void ConfigureDialog::UpdateVisibleTabs() {
+    const auto items = ui->selectorList->selectedItems();
+    if (items.isEmpty())
+        return;
+
+    const std::map<QString, QWidget*> widgets = {{tr("General"), ui->generalTab},
+                                                 {tr("System"), ui->systemTab},
+                                                 {tr("Profiles"), ui->profileManagerTab},
+                                                 {tr("Input"), ui->inputTab},
+                                                 {tr("Graphics"), ui->graphicsTab},
+                                                 {tr("Audio"), ui->audioTab},
+                                                 {tr("Debug"), ui->debugTab},
+                                                 {tr("Web"), ui->webTab},
+                                                 {tr("Game List"), ui->gameListTab}};
+
+    ui->tabWidget->clear();
+
+    const QStringList tabs = items[0]->data(Qt::UserRole).toStringList();
+
+    for (const auto& tab : tabs)
+        ui->tabWidget->addTab(widgets.find(tab)->second, tab);
+}

src/yuzu/configuration/configure_dialog.h

@@ -24,6 +24,8 @@ public:
 
 private:
     void setConfiguration();
+    void UpdateVisibleTabs();
+    void PopulateSelectionList();
 
     std::unique_ptr<Ui::ConfigureDialog> ui;
 };

src/yuzu/configuration/configure_general.cpp

@@ -30,6 +30,7 @@ ConfigureGeneral::~ConfigureGeneral() = default;
 void ConfigureGeneral::setConfiguration() {
     ui->toggle_deepscan->setChecked(UISettings::values.gamedir_deepscan);
     ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing);
+    ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot);
     ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
     ui->use_cpu_jit->setChecked(Settings::values.use_cpu_jit);
     ui->enable_nfc->setChecked(Settings::values.enable_nfc);
@@ -42,6 +43,7 @@ void ConfigureGeneral::PopulateHotkeyList(const HotkeyRegistry& registry) {
 void ConfigureGeneral::applyConfiguration() {
     UISettings::values.gamedir_deepscan = ui->toggle_deepscan->isChecked();
     UISettings::values.confirm_before_closing = ui->toggle_check_exit->isChecked();
+    UISettings::values.select_user_on_boot = ui->toggle_user_on_boot->isChecked();
     UISettings::values.theme =
         ui->theme_combobox->itemData(ui->theme_combobox->currentIndex()).toString();
 

src/yuzu/configuration/configure_general.ui

@@ -38,6 +38,13 @@
             </property>
            </widget>
           </item>
+          <item>
+           <widget class="QCheckBox" name="toggle_user_on_boot">
+            <property name="text">
+             <string>Prompt for user on game boot</string>
+            </property>
+           </widget>
+          </item>
          </layout>
         </item>
        </layout>

src/yuzu/configuration/configure_input_player.cpp

@@ -7,6 +7,7 @@
 #include <utility>
 #include <QColorDialog>
 #include <QGridLayout>
+#include <QKeyEvent>
 #include <QMenu>
 #include <QMessageBox>
 #include <QTimer>

src/yuzu/configuration/configure_input_player.h

@@ -11,17 +11,21 @@
 #include <string>
 
 #include <QDialog>
-#include <QKeyEvent>
 
 #include "common/param_package.h"
 #include "core/settings.h"
-#include "input_common/main.h"
 #include "ui_configure_input.h"
 
+class QKeyEvent;
 class QPushButton;
 class QString;
 class QTimer;
 
+namespace InputCommon::Polling {
+class DevicePoller;
+enum class DeviceType;
+} // namespace InputCommon::Polling
+
 namespace Ui {
 class ConfigureInputPlayer;
 }

src/yuzu/configuration/configure_per_general.cpp

@@ -8,7 +8,6 @@
 
 #include <QHeaderView>
 #include <QMenu>
-#include <QMessageBox>
 #include <QStandardItemModel>
 #include <QString>
 #include <QTimer>
@@ -120,7 +119,7 @@ void ConfigurePerGameGeneral::loadConfiguration() {
 
         QPixmap map;
         const auto bytes = control.second->ReadAllBytes();
-        map.loadFromData(bytes.data(), bytes.size());
+        map.loadFromData(bytes.data(), static_cast<u32>(bytes.size()));
 
         scene->addPixmap(map.scaled(ui->icon_view->width(), ui->icon_view->height(),
                                     Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
@@ -130,7 +129,7 @@ void ConfigurePerGameGeneral::loadConfiguration() {
             scene->clear();
 
             QPixmap map;
-            map.loadFromData(bytes.data(), bytes.size());
+            map.loadFromData(bytes.data(), static_cast<u32>(bytes.size()));
 
             scene->addPixmap(map.scaled(ui->icon_view->width(), ui->icon_view->height(),
                                         Qt::IgnoreAspectRatio, Qt::SmoothTransformation));

src/yuzu/configuration/configure_per_general.h

@@ -7,16 +7,16 @@
 #include <memory>
 #include <vector>
 
-#include <QKeyEvent>
+#include <QDialog>
 #include <QList>
-#include <QWidget>
 
 #include "core/file_sys/vfs_types.h"
 
-class QTreeView;
 class QGraphicsScene;
 class QStandardItem;
 class QStandardItemModel;
+class QTreeView;
+class QVBoxLayout;
 
 namespace Ui {
 class ConfigurePerGameGeneral;

src/yuzu/configuration/configure_profile_manager.cpp

@@ -0,0 +1,300 @@
+// Copyright 2016 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <QFileDialog>
+#include <QGraphicsItem>
+#include <QGraphicsScene>
+#include <QHeaderView>
+#include <QMessageBox>
+#include <QStandardItemModel>
+#include <QTreeView>
+#include <QVBoxLayout>
+#include "common/assert.h"
+#include "common/file_util.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/settings.h"
+#include "ui_configure_profile_manager.h"
+#include "yuzu/configuration/configure_profile_manager.h"
+#include "yuzu/util/limitable_input_dialog.h"
+
+namespace {
+// Same backup JPEG used by acc IProfile::GetImage if no jpeg found
+constexpr std::array<u8, 107> 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,
+};
+
+QString GetImagePath(Service::Account::UUID uuid) {
+    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
+                      "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
+    return QString::fromStdString(path);
+}
+
+QString GetAccountUsername(const Service::Account::ProfileManager& manager,
+                           Service::Account::UUID uuid) {
+    Service::Account::ProfileBase profile;
+    if (!manager.GetProfileBase(uuid, profile)) {
+        return {};
+    }
+
+    const auto text = Common::StringFromFixedZeroTerminatedBuffer(
+        reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
+    return QString::fromStdString(text);
+}
+
+QString FormatUserEntryText(const QString& username, Service::Account::UUID uuid) {
+    return ConfigureProfileManager::tr("%1\n%2",
+                                       "%1 is the profile username, %2 is the formatted UUID (e.g. "
+                                       "00112233-4455-6677-8899-AABBCCDDEEFF))")
+        .arg(username, QString::fromStdString(uuid.FormatSwitch()));
+}
+
+QPixmap GetIcon(Service::Account::UUID uuid) {
+    QPixmap icon{GetImagePath(uuid)};
+
+    if (!icon) {
+        icon.fill(Qt::black);
+        icon.loadFromData(backup_jpeg.data(), static_cast<u32>(backup_jpeg.size()));
+    }
+
+    return icon.scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+}
+
+QString GetProfileUsernameFromUser(QWidget* parent, const QString& description_text) {
+    return LimitableInputDialog::GetText(parent, ConfigureProfileManager::tr("Enter Username"),
+                                         description_text, 1,
+                                         static_cast<int>(Service::Account::profile_username_size));
+}
+} // Anonymous namespace
+
+ConfigureProfileManager ::ConfigureProfileManager(QWidget* parent)
+    : QWidget(parent), ui(new Ui::ConfigureProfileManager),
+      profile_manager(std::make_unique<Service::Account::ProfileManager>()) {
+    ui->setupUi(this);
+
+    layout = new QVBoxLayout;
+    tree_view = new QTreeView;
+    item_model = new QStandardItemModel(tree_view);
+    tree_view->setModel(item_model);
+
+    tree_view->setAlternatingRowColors(true);
+    tree_view->setSelectionMode(QHeaderView::SingleSelection);
+    tree_view->setSelectionBehavior(QHeaderView::SelectRows);
+    tree_view->setVerticalScrollMode(QHeaderView::ScrollPerPixel);
+    tree_view->setHorizontalScrollMode(QHeaderView::ScrollPerPixel);
+    tree_view->setSortingEnabled(true);
+    tree_view->setEditTriggers(QHeaderView::NoEditTriggers);
+    tree_view->setUniformRowHeights(true);
+    tree_view->setIconSize({64, 64});
+    tree_view->setContextMenuPolicy(Qt::NoContextMenu);
+
+    item_model->insertColumns(0, 1);
+    item_model->setHeaderData(0, Qt::Horizontal, "Users");
+
+    // We must register all custom types with the Qt Automoc system so that we are able to use it
+    // with signals/slots. In this case, QList falls under the umbrells of custom types.
+    qRegisterMetaType<QList<QStandardItem*>>("QList<QStandardItem*>");
+
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+    layout->addWidget(tree_view);
+
+    ui->scrollArea->setLayout(layout);
+
+    connect(tree_view, &QTreeView::clicked, this, &ConfigureProfileManager::SelectUser);
+
+    connect(ui->pm_add, &QPushButton::pressed, this, &ConfigureProfileManager::AddUser);
+    connect(ui->pm_rename, &QPushButton::pressed, this, &ConfigureProfileManager::RenameUser);
+    connect(ui->pm_remove, &QPushButton::pressed, this, &ConfigureProfileManager::DeleteUser);
+    connect(ui->pm_set_image, &QPushButton::pressed, this, &ConfigureProfileManager::SetUserImage);
+
+    scene = new QGraphicsScene;
+    ui->current_user_icon->setScene(scene);
+
+    this->setConfiguration();
+}
+
+ConfigureProfileManager::~ConfigureProfileManager() = default;
+
+void ConfigureProfileManager::setConfiguration() {
+    enabled = !Core::System::GetInstance().IsPoweredOn();
+    item_model->removeRows(0, item_model->rowCount());
+    list_items.clear();
+
+    PopulateUserList();
+    UpdateCurrentUser();
+}
+
+void ConfigureProfileManager::PopulateUserList() {
+    const auto& profiles = profile_manager->GetAllUsers();
+    for (const auto& user : profiles) {
+        Service::Account::ProfileBase profile;
+        if (!profile_manager->GetProfileBase(user, profile))
+            continue;
+
+        const auto username = Common::StringFromFixedZeroTerminatedBuffer(
+            reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
+
+        list_items.push_back(QList<QStandardItem*>{new QStandardItem{
+            GetIcon(user), FormatUserEntryText(QString::fromStdString(username), user)}});
+    }
+
+    for (const auto& item : list_items)
+        item_model->appendRow(item);
+}
+
+void ConfigureProfileManager::UpdateCurrentUser() {
+    ui->pm_add->setEnabled(profile_manager->GetUserCount() < Service::Account::MAX_USERS);
+
+    const auto& current_user = profile_manager->GetUser(Settings::values.current_user);
+    ASSERT(current_user);
+    const auto username = GetAccountUsername(*profile_manager, *current_user);
+
+    scene->clear();
+    scene->addPixmap(
+        GetIcon(*current_user).scaled(48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
+    ui->current_user_username->setText(username);
+}
+
+void ConfigureProfileManager::applyConfiguration() {
+    if (!enabled)
+        return;
+
+    Settings::Apply();
+}
+
+void ConfigureProfileManager::SelectUser(const QModelIndex& index) {
+    Settings::values.current_user =
+        std::clamp<s32>(index.row(), 0, static_cast<s32>(profile_manager->GetUserCount() - 1));
+
+    UpdateCurrentUser();
+
+    ui->pm_remove->setEnabled(profile_manager->GetUserCount() >= 2);
+    ui->pm_rename->setEnabled(true);
+    ui->pm_set_image->setEnabled(true);
+}
+
+void ConfigureProfileManager::AddUser() {
+    const auto username =
+        GetProfileUsernameFromUser(this, tr("Enter a username for the new user:"));
+    if (username.isEmpty()) {
+        return;
+    }
+
+    const auto uuid = Service::Account::UUID::Generate();
+    profile_manager->CreateNewUser(uuid, username.toStdString());
+
+    item_model->appendRow(new QStandardItem{GetIcon(uuid), FormatUserEntryText(username, uuid)});
+}
+
+void ConfigureProfileManager::RenameUser() {
+    const auto user = tree_view->currentIndex().row();
+    const auto uuid = profile_manager->GetUser(user);
+    ASSERT(uuid);
+
+    Service::Account::ProfileBase profile;
+    if (!profile_manager->GetProfileBase(*uuid, profile))
+        return;
+
+    const auto new_username = GetProfileUsernameFromUser(this, tr("Enter a new username:"));
+    if (new_username.isEmpty()) {
+        return;
+    }
+
+    const auto username_std = new_username.toStdString();
+    std::fill(profile.username.begin(), profile.username.end(), '\0');
+    std::copy(username_std.begin(), username_std.end(), profile.username.begin());
+
+    profile_manager->SetProfileBase(*uuid, profile);
+
+    item_model->setItem(
+        user, 0,
+        new QStandardItem{GetIcon(*uuid),
+                          FormatUserEntryText(QString::fromStdString(username_std), *uuid)});
+    UpdateCurrentUser();
+}
+
+void ConfigureProfileManager::DeleteUser() {
+    const auto index = tree_view->currentIndex().row();
+    const auto uuid = profile_manager->GetUser(index);
+    ASSERT(uuid);
+    const auto username = GetAccountUsername(*profile_manager, *uuid);
+
+    const auto confirm = QMessageBox::question(
+        this, tr("Confirm Delete"),
+        tr("You are about to delete user with name \"%1\". Are you sure?").arg(username));
+
+    if (confirm == QMessageBox::No)
+        return;
+
+    if (Settings::values.current_user == tree_view->currentIndex().row())
+        Settings::values.current_user = 0;
+    UpdateCurrentUser();
+
+    if (!profile_manager->RemoveUser(*uuid))
+        return;
+
+    item_model->removeRows(tree_view->currentIndex().row(), 1);
+    tree_view->clearSelection();
+
+    ui->pm_remove->setEnabled(false);
+    ui->pm_rename->setEnabled(false);
+}
+
+void ConfigureProfileManager::SetUserImage() {
+    const auto index = tree_view->currentIndex().row();
+    const auto uuid = profile_manager->GetUser(index);
+    ASSERT(uuid);
+
+    const auto file = QFileDialog::getOpenFileName(this, tr("Select User Image"), QString(),
+                                                   tr("JPEG Images (*.jpg *.jpeg)"));
+
+    if (file.isEmpty()) {
+        return;
+    }
+
+    const auto image_path = GetImagePath(*uuid);
+    if (QFile::exists(image_path) && !QFile::remove(image_path)) {
+        QMessageBox::warning(
+            this, tr("Error deleting image"),
+            tr("Error occurred attempting to overwrite previous image at: %1.").arg(image_path));
+        return;
+    }
+
+    const auto raw_path = QString::fromStdString(
+        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000010");
+    const QFileInfo raw_info{raw_path};
+    if (raw_info.exists() && !raw_info.isDir() && !QFile::remove(raw_path)) {
+        QMessageBox::warning(this, tr("Error deleting file"),
+                             tr("Unable to delete existing file: %1.").arg(raw_path));
+        return;
+    }
+
+    const QString absolute_dst_path = QFileInfo{image_path}.absolutePath();
+    if (!QDir{raw_path}.mkpath(absolute_dst_path)) {
+        QMessageBox::warning(
+            this, tr("Error creating user image directory"),
+            tr("Unable to create directory %1 for storing user images.").arg(absolute_dst_path));
+        return;
+    }
+
+    if (!QFile::copy(file, image_path)) {
+        QMessageBox::warning(this, tr("Error copying user image"),
+                             tr("Unable to copy image from %1 to %2").arg(file, image_path));
+        return;
+    }
+
+    const auto username = GetAccountUsername(*profile_manager, *uuid);
+    item_model->setItem(index, 0,
+                        new QStandardItem{GetIcon(*uuid), FormatUserEntryText(username, *uuid)});
+    UpdateCurrentUser();
+}

src/yuzu/configuration/configure_profile_manager.h

@@ -0,0 +1,57 @@
+// Copyright 2016 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+
+#include <QList>
+#include <QWidget>
+
+class QGraphicsScene;
+class QStandardItem;
+class QStandardItemModel;
+class QTreeView;
+class QVBoxLayout;
+
+namespace Service::Account {
+class ProfileManager;
+}
+
+namespace Ui {
+class ConfigureProfileManager;
+}
+
+class ConfigureProfileManager : public QWidget {
+    Q_OBJECT
+
+public:
+    explicit ConfigureProfileManager(QWidget* parent = nullptr);
+    ~ConfigureProfileManager() override;
+
+    void applyConfiguration();
+    void setConfiguration();
+
+private:
+    void PopulateUserList();
+    void UpdateCurrentUser();
+
+    void SelectUser(const QModelIndex& index);
+    void AddUser();
+    void RenameUser();
+    void DeleteUser();
+    void SetUserImage();
+
+    QVBoxLayout* layout;
+    QTreeView* tree_view;
+    QStandardItemModel* item_model;
+    QGraphicsScene* scene;
+
+    std::vector<QList<QStandardItem*>> list_items;
+
+    std::unique_ptr<Ui::ConfigureProfileManager> ui;
+    bool enabled = false;
+
+    std::unique_ptr<Service::Account::ProfileManager> profile_manager;
+};

src/yuzu/configuration/configure_profile_manager.ui

@@ -0,0 +1,172 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ConfigureProfileManager</class>
+ <widget class="QWidget" name="ConfigureProfileManager">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>366</width>
+    <height>483</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout">
+   <item>
+    <layout class="QVBoxLayout" name="verticalLayout">
+     <item>
+      <widget class="QGroupBox" name="gridGroupBox">
+       <property name="title">
+        <string>Profile Manager</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout_2">
+        <property name="sizeConstraint">
+         <enum>QLayout::SetNoConstraint</enum>
+        </property>
+        <item row="0" column="0">
+         <layout class="QHBoxLayout" name="horizontalLayout_2">
+          <item>
+           <widget class="QLabel" name="label">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="text">
+             <string>Current User</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QGraphicsView" name="current_user_icon">
+            <property name="minimumSize">
+             <size>
+              <width>48</width>
+              <height>48</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>48</width>
+              <height>48</height>
+             </size>
+            </property>
+            <property name="verticalScrollBarPolicy">
+             <enum>Qt::ScrollBarAlwaysOff</enum>
+            </property>
+            <property name="horizontalScrollBarPolicy">
+             <enum>Qt::ScrollBarAlwaysOff</enum>
+            </property>
+            <property name="interactive">
+             <bool>false</bool>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="current_user_username">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="text">
+             <string>Username</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+        <item row="1" column="0">
+         <widget class="QScrollArea" name="scrollArea">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="frameShape">
+           <enum>QFrame::StyledPanel</enum>
+          </property>
+          <property name="widgetResizable">
+           <bool>false</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="0">
+         <layout class="QHBoxLayout" name="horizontalLayout_3">
+          <item>
+           <widget class="QPushButton" name="pm_set_image">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="text">
+             <string>Set Image</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <spacer name="horizontalSpacer">
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>40</width>
+              <height>20</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+          <item>
+           <widget class="QPushButton" name="pm_add">
+            <property name="text">
+             <string>Add</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="pm_rename">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="text">
+             <string>Rename</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="pm_remove">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="text">
+             <string>Remove</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="label_disable_info">
+       <property name="text">
+        <string>Profile management is available only when game is not running.</string>
+       </property>
+       <property name="wordWrap">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

src/yuzu/configuration/configure_system.cpp

@@ -2,24 +2,19 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
+#include <array>
+#include <chrono>
+#include <optional>
+
 #include <QFileDialog>
 #include <QGraphicsItem>
-#include <QGraphicsScene>
-#include <QHeaderView>
 #include <QMessageBox>
-#include <QStandardItemModel>
-#include <QTreeView>
-#include <QVBoxLayout>
 #include "common/assert.h"
 #include "common/file_util.h"
-#include "common/string_util.h"
 #include "core/core.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 #include "ui_configure_system.h"
 #include "yuzu/configuration/configure_system.h"
-#include "yuzu/util/limitable_input_dialog.h"
 
 namespace {
 constexpr std::array<int, 12> days_in_month = {{
@@ -36,64 +31,9 @@ constexpr std::array<int, 12> days_in_month = {{
     30,
     31,
 }};
-
-// Same backup JPEG used by acc IProfile::GetImage if no jpeg found
-constexpr std::array<u8, 107> 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,
-};
-
-QString GetImagePath(Service::Account::UUID uuid) {
-    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-                      "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
-    return QString::fromStdString(path);
-}
-
-QString GetAccountUsername(const Service::Account::ProfileManager& manager,
-                           Service::Account::UUID uuid) {
-    Service::Account::ProfileBase profile;
-    if (!manager.GetProfileBase(uuid, profile)) {
-        return {};
-    }
-
-    const auto text = Common::StringFromFixedZeroTerminatedBuffer(
-        reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
-    return QString::fromStdString(text);
-}
-
-QString FormatUserEntryText(const QString& username, Service::Account::UUID uuid) {
-    return ConfigureSystem::tr("%1\n%2",
-                               "%1 is the profile username, %2 is the formatted UUID (e.g. "
-                               "00112233-4455-6677-8899-AABBCCDDEEFF))")
-        .arg(username, QString::fromStdString(uuid.FormatSwitch()));
-}
-
-QPixmap GetIcon(Service::Account::UUID uuid) {
-    QPixmap icon{GetImagePath(uuid)};
-
-    if (!icon) {
-        icon.fill(Qt::black);
-        icon.loadFromData(backup_jpeg.data(), static_cast<u32>(backup_jpeg.size()));
-    }
-
-    return icon.scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
-}
-
-QString GetProfileUsernameFromUser(QWidget* parent, const QString& description_text) {
-    return LimitableInputDialog::GetText(parent, ConfigureSystem::tr("Enter Username"),
-                                         description_text, 1,
-                                         static_cast<int>(Service::Account::profile_username_size));
-}
 } // Anonymous namespace
 
-ConfigureSystem::ConfigureSystem(QWidget* parent)
-    : QWidget(parent), ui(new Ui::ConfigureSystem),
-      profile_manager(std::make_unique<Service::Account::ProfileManager>()) {
+ConfigureSystem::ConfigureSystem(QWidget* parent) : QWidget(parent), ui(new Ui::ConfigureSystem) {
     ui->setupUi(this);
     connect(ui->combo_birthmonth,
             static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
@@ -101,50 +41,17 @@ ConfigureSystem::ConfigureSystem(QWidget* parent)
     connect(ui->button_regenerate_console_id, &QPushButton::clicked, this,
             &ConfigureSystem::RefreshConsoleID);
 
-    layout = new QVBoxLayout;
-    tree_view = new QTreeView;
-    item_model = new QStandardItemModel(tree_view);
-    tree_view->setModel(item_model);
-
-    tree_view->setAlternatingRowColors(true);
-    tree_view->setSelectionMode(QHeaderView::SingleSelection);
-    tree_view->setSelectionBehavior(QHeaderView::SelectRows);
-    tree_view->setVerticalScrollMode(QHeaderView::ScrollPerPixel);
-    tree_view->setHorizontalScrollMode(QHeaderView::ScrollPerPixel);
-    tree_view->setSortingEnabled(true);
-    tree_view->setEditTriggers(QHeaderView::NoEditTriggers);
-    tree_view->setUniformRowHeights(true);
-    tree_view->setIconSize({64, 64});
-    tree_view->setContextMenuPolicy(Qt::NoContextMenu);
-
-    item_model->insertColumns(0, 1);
-    item_model->setHeaderData(0, Qt::Horizontal, "Users");
-
-    // We must register all custom types with the Qt Automoc system so that we are able to use it
-    // with signals/slots. In this case, QList falls under the umbrells of custom types.
-    qRegisterMetaType<QList<QStandardItem*>>("QList<QStandardItem*>");
-
-    layout->setContentsMargins(0, 0, 0, 0);
-    layout->setSpacing(0);
-    layout->addWidget(tree_view);
-
-    ui->scrollArea->setLayout(layout);
-
-    connect(tree_view, &QTreeView::clicked, this, &ConfigureSystem::SelectUser);
-
-    connect(ui->pm_add, &QPushButton::pressed, this, &ConfigureSystem::AddUser);
-    connect(ui->pm_rename, &QPushButton::pressed, this, &ConfigureSystem::RenameUser);
-    connect(ui->pm_remove, &QPushButton::pressed, this, &ConfigureSystem::DeleteUser);
-    connect(ui->pm_set_image, &QPushButton::pressed, this, &ConfigureSystem::SetUserImage);
-
     connect(ui->rng_seed_checkbox, &QCheckBox::stateChanged, this, [this](bool checked) {
         ui->rng_seed_edit->setEnabled(checked);
         if (!checked)
             ui->rng_seed_edit->setText(QStringLiteral("00000000"));
     });
 
-    scene = new QGraphicsScene;
-    ui->current_user_icon->setScene(scene);
+    connect(ui->custom_rtc_checkbox, &QCheckBox::stateChanged, this, [this](bool checked) {
+        ui->custom_rtc_edit->setEnabled(checked);
+        if (!checked)
+            ui->custom_rtc_edit->setDateTime(QDateTime::currentDateTime());
+    });
 
     this->setConfiguration();
 }
@@ -156,49 +63,19 @@ void ConfigureSystem::setConfiguration() {
 
     ui->combo_language->setCurrentIndex(Settings::values.language_index);
 
-    item_model->removeRows(0, item_model->rowCount());
-    list_items.clear();
-
-    PopulateUserList();
-    UpdateCurrentUser();
-
     ui->rng_seed_checkbox->setChecked(Settings::values.rng_seed.has_value());
     ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.has_value());
 
     const auto rng_seed =
         QString("%1").arg(Settings::values.rng_seed.value_or(0), 8, 16, QLatin1Char{'0'}).toUpper();
     ui->rng_seed_edit->setText(rng_seed);
-}
 
-void ConfigureSystem::PopulateUserList() {
-    const auto& profiles = profile_manager->GetAllUsers();
-    for (const auto& user : profiles) {
-        Service::Account::ProfileBase profile;
-        if (!profile_manager->GetProfileBase(user, profile))
-            continue;
+    ui->custom_rtc_checkbox->setChecked(Settings::values.custom_rtc.has_value());
+    ui->custom_rtc_edit->setEnabled(Settings::values.custom_rtc.has_value());
 
-        const auto username = Common::StringFromFixedZeroTerminatedBuffer(
-            reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
-
-        list_items.push_back(QList<QStandardItem*>{new QStandardItem{
-            GetIcon(user), FormatUserEntryText(QString::fromStdString(username), user)}});
-    }
-
-    for (const auto& item : list_items)
-        item_model->appendRow(item);
-}
-
-void ConfigureSystem::UpdateCurrentUser() {
-    ui->pm_add->setEnabled(profile_manager->GetUserCount() < Service::Account::MAX_USERS);
-
-    const auto& current_user = profile_manager->GetUser(Settings::values.current_user);
-    ASSERT(current_user);
-    const auto username = GetAccountUsername(*profile_manager, *current_user);
-
-    scene->clear();
-    scene->addPixmap(
-        GetIcon(*current_user).scaled(48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
-    ui->current_user_username->setText(username);
+    const auto rtc_time = Settings::values.custom_rtc.value_or(
+        std::chrono::seconds(QDateTime::currentSecsSinceEpoch()));
+    ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time.count()));
 }
 
 void ConfigureSystem::ReadSystemSettings() {}
@@ -214,6 +91,12 @@ void ConfigureSystem::applyConfiguration() {
     else
         Settings::values.rng_seed = std::nullopt;
 
+    if (ui->custom_rtc_checkbox->isChecked())
+        Settings::values.custom_rtc =
+            std::chrono::seconds(ui->custom_rtc_edit->dateTime().toSecsSinceEpoch());
+    else
+        Settings::values.custom_rtc = std::nullopt;
+
     Settings::Apply();
 }
 
@@ -256,130 +139,3 @@ void ConfigureSystem::RefreshConsoleID() {
     ui->label_console_id->setText(
         tr("Console ID: 0x%1").arg(QString::number(console_id, 16).toUpper()));
 }
-
-void ConfigureSystem::SelectUser(const QModelIndex& index) {
-    Settings::values.current_user =
-        std::clamp<s32>(index.row(), 0, static_cast<s32>(profile_manager->GetUserCount() - 1));
-
-    UpdateCurrentUser();
-
-    ui->pm_remove->setEnabled(profile_manager->GetUserCount() >= 2);
-    ui->pm_rename->setEnabled(true);
-    ui->pm_set_image->setEnabled(true);
-}
-
-void ConfigureSystem::AddUser() {
-    const auto username =
-        GetProfileUsernameFromUser(this, tr("Enter a username for the new user:"));
-    if (username.isEmpty()) {
-        return;
-    }
-
-    const auto uuid = Service::Account::UUID::Generate();
-    profile_manager->CreateNewUser(uuid, username.toStdString());
-
-    item_model->appendRow(new QStandardItem{GetIcon(uuid), FormatUserEntryText(username, uuid)});
-}
-
-void ConfigureSystem::RenameUser() {
-    const auto user = tree_view->currentIndex().row();
-    const auto uuid = profile_manager->GetUser(user);
-    ASSERT(uuid);
-
-    Service::Account::ProfileBase profile;
-    if (!profile_manager->GetProfileBase(*uuid, profile))
-        return;
-
-    const auto new_username = GetProfileUsernameFromUser(this, tr("Enter a new username:"));
-    if (new_username.isEmpty()) {
-        return;
-    }
-
-    const auto username_std = new_username.toStdString();
-    std::fill(profile.username.begin(), profile.username.end(), '\0');
-    std::copy(username_std.begin(), username_std.end(), profile.username.begin());
-
-    profile_manager->SetProfileBase(*uuid, profile);
-
-    item_model->setItem(
-        user, 0,
-        new QStandardItem{GetIcon(*uuid),
-                          FormatUserEntryText(QString::fromStdString(username_std), *uuid)});
-    UpdateCurrentUser();
-}
-
-void ConfigureSystem::DeleteUser() {
-    const auto index = tree_view->currentIndex().row();
-    const auto uuid = profile_manager->GetUser(index);
-    ASSERT(uuid);
-    const auto username = GetAccountUsername(*profile_manager, *uuid);
-
-    const auto confirm = QMessageBox::question(
-        this, tr("Confirm Delete"),
-        tr("You are about to delete user with name \"%1\". Are you sure?").arg(username));
-
-    if (confirm == QMessageBox::No)
-        return;
-
-    if (Settings::values.current_user == tree_view->currentIndex().row())
-        Settings::values.current_user = 0;
-    UpdateCurrentUser();
-
-    if (!profile_manager->RemoveUser(*uuid))
-        return;
-
-    item_model->removeRows(tree_view->currentIndex().row(), 1);
-    tree_view->clearSelection();
-
-    ui->pm_remove->setEnabled(false);
-    ui->pm_rename->setEnabled(false);
-}
-
-void ConfigureSystem::SetUserImage() {
-    const auto index = tree_view->currentIndex().row();
-    const auto uuid = profile_manager->GetUser(index);
-    ASSERT(uuid);
-
-    const auto file = QFileDialog::getOpenFileName(this, tr("Select User Image"), QString(),
-                                                   tr("JPEG Images (*.jpg *.jpeg)"));
-
-    if (file.isEmpty()) {
-        return;
-    }
-
-    const auto image_path = GetImagePath(*uuid);
-    if (QFile::exists(image_path) && !QFile::remove(image_path)) {
-        QMessageBox::warning(
-            this, tr("Error deleting image"),
-            tr("Error occurred attempting to overwrite previous image at: %1.").arg(image_path));
-        return;
-    }
-
-    const auto raw_path = QString::fromStdString(
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000010");
-    const QFileInfo raw_info{raw_path};
-    if (raw_info.exists() && !raw_info.isDir() && !QFile::remove(raw_path)) {
-        QMessageBox::warning(this, tr("Error deleting file"),
-                             tr("Unable to delete existing file: %1.").arg(raw_path));
-        return;
-    }
-
-    const QString absolute_dst_path = QFileInfo{image_path}.absolutePath();
-    if (!QDir{raw_path}.mkpath(absolute_dst_path)) {
-        QMessageBox::warning(
-            this, tr("Error creating user image directory"),
-            tr("Unable to create directory %1 for storing user images.").arg(absolute_dst_path));
-        return;
-    }
-
-    if (!QFile::copy(file, image_path)) {
-        QMessageBox::warning(this, tr("Error copying user image"),
-                             tr("Unable to copy image from %1 to %2").arg(file, image_path));
-        return;
-    }
-
-    const auto username = GetAccountUsername(*profile_manager, *uuid);
-    item_model->setItem(index, 0,
-                        new QStandardItem{GetIcon(*uuid), FormatUserEntryText(username, *uuid)});
-    UpdateCurrentUser();
-}

src/yuzu/configuration/configure_system.h

@@ -9,16 +9,6 @@
 #include <QList>
 #include <QWidget>
 
-class QGraphicsScene;
-class QStandardItem;
-class QStandardItemModel;
-class QTreeView;
-class QVBoxLayout;
-
-namespace Service::Account {
-class ProfileManager;
-}
-
 namespace Ui {
 class ConfigureSystem;
 }
@@ -39,21 +29,6 @@ private:
     void UpdateBirthdayComboBox(int birthmonth_index);
     void RefreshConsoleID();
 
-    void PopulateUserList();
-    void UpdateCurrentUser();
-    void SelectUser(const QModelIndex& index);
-    void AddUser();
-    void RenameUser();
-    void DeleteUser();
-    void SetUserImage();
-
-    QVBoxLayout* layout;
-    QTreeView* tree_view;
-    QStandardItemModel* item_model;
-    QGraphicsScene* scene;
-
-    std::vector<QList<QStandardItem*>> list_items;
-
     std::unique_ptr<Ui::ConfigureSystem> ui;
     bool enabled = false;
 
@@ -61,6 +36,4 @@ private:
     int birthday = 0;
     int language_index = 0;
     int sound_index = 0;
-
-    std::unique_ptr<Service::Account::ProfileManager> profile_manager;
 };

src/yuzu/configuration/configure_system.ui

@@ -22,6 +22,13 @@
         <string>System Settings</string>
        </property>
        <layout class="QGridLayout" name="gridLayout">
+        <item row="2" column="0">
+         <widget class="QLabel" name="label_sound">
+          <property name="text">
+           <string>Sound output mode</string>
+          </property>
+         </widget>
+        </item>
         <item row="1" column="1">
          <widget class="QComboBox" name="combo_language">
           <property name="toolTip">
@@ -114,27 +121,6 @@
           </item>
          </widget>
         </item>
-        <item row="3" column="0">
-         <widget class="QLabel" name="label_console_id">
-          <property name="text">
-           <string>Console ID:</string>
-          </property>
-         </widget>
-        </item>
-        <item row="2" column="0">
-         <widget class="QLabel" name="label_sound">
-          <property name="text">
-           <string>Sound output mode</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="0">
-         <widget class="QLabel" name="label_birthday">
-          <property name="text">
-           <string>Birthday</string>
-          </property>
-         </widget>
-        </item>
         <item row="0" column="1">
          <layout class="QHBoxLayout" name="horizontalLayout_birthday2">
           <item>
@@ -206,6 +192,20 @@
           </item>
          </layout>
         </item>
+        <item row="3" column="0">
+         <widget class="QLabel" name="label_console_id">
+          <property name="text">
+           <string>Console ID:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="0">
+         <widget class="QLabel" name="label_birthday">
+          <property name="text">
+           <string>Birthday</string>
+          </property>
+         </widget>
+        </item>
         <item row="3" column="1">
          <widget class="QPushButton" name="button_regenerate_console_id">
           <property name="sizePolicy">
@@ -241,6 +241,13 @@
           </item>
          </widget>
         </item>
+        <item row="5" column="0">
+         <widget class="QCheckBox" name="rng_seed_checkbox">
+          <property name="text">
+           <string>RNG Seed</string>
+          </property>
+         </widget>
+        </item>
         <item row="1" column="0">
          <widget class="QLabel" name="label_language">
           <property name="text">
@@ -248,14 +255,7 @@
           </property>
          </widget>
         </item>
-        <item row="4" column="0">
-         <widget class="QCheckBox" name="rng_seed_checkbox">
-          <property name="text">
-           <string>RNG Seed</string>
-          </property>
-         </widget>
-        </item>
-        <item row="4" column="1">
+        <item row="5" column="1">
          <widget class="QLineEdit" name="rng_seed_edit">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
@@ -276,145 +276,42 @@
           </property>
          </widget>
         </item>
+        <item row="4" column="0">
+         <widget class="QCheckBox" name="custom_rtc_checkbox">
+          <property name="text">
+           <string>Custom RTC</string>
+          </property>
+         </widget>
+        </item>
+        <item row="4" column="1">
+         <widget class="QDateTimeEdit" name="custom_rtc_edit">
+          <property name="minimumDate">
+           <date>
+            <year>1970</year>
+            <month>1</month>
+            <day>1</day>
+           </date>
+          </property>
+          <property name="displayFormat">
+           <string>d MMM yyyy h:mm:ss AP</string>
+          </property>
+         </widget>
+        </item>
        </layout>
       </widget>
      </item>
      <item>
-      <widget class="QGroupBox" name="gridGroupBox">
-       <property name="title">
-        <string>Profile Manager</string>
+      <spacer name="verticalSpacer">
+       <property name="orientation">
+        <enum>Qt::Vertical</enum>
        </property>
-       <layout class="QGridLayout" name="gridLayout_2">
-        <property name="sizeConstraint">
-         <enum>QLayout::SetNoConstraint</enum>
-        </property>
-        <item row="0" column="0">
-         <layout class="QHBoxLayout" name="horizontalLayout_2">
-          <item>
-           <widget class="QLabel" name="label">
-            <property name="sizePolicy">
-             <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
-              <horstretch>0</horstretch>
-              <verstretch>0</verstretch>
-             </sizepolicy>
-            </property>
-            <property name="text">
-             <string>Current User</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QGraphicsView" name="current_user_icon">
-            <property name="minimumSize">
-             <size>
-              <width>48</width>
-              <height>48</height>
-             </size>
-            </property>
-            <property name="maximumSize">
-             <size>
-              <width>48</width>
-              <height>48</height>
-             </size>
-            </property>
-            <property name="verticalScrollBarPolicy">
-             <enum>Qt::ScrollBarAlwaysOff</enum>
-            </property>
-            <property name="horizontalScrollBarPolicy">
-             <enum>Qt::ScrollBarAlwaysOff</enum>
-            </property>
-            <property name="interactive">
-             <bool>false</bool>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QLabel" name="current_user_username">
-            <property name="sizePolicy">
-             <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
-              <horstretch>0</horstretch>
-              <verstretch>0</verstretch>
-             </sizepolicy>
-            </property>
-            <property name="text">
-             <string>Username</string>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
-        <item row="1" column="0">
-         <widget class="QScrollArea" name="scrollArea">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="frameShape">
-           <enum>QFrame::StyledPanel</enum>
-          </property>
-          <property name="widgetResizable">
-           <bool>false</bool>
-          </property>
-         </widget>
-        </item>
-        <item row="2" column="0">
-         <layout class="QHBoxLayout" name="horizontalLayout_3">
-          <item>
-           <widget class="QPushButton" name="pm_set_image">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="text">
-             <string>Set Image</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <spacer name="horizontalSpacer">
-            <property name="orientation">
-             <enum>Qt::Horizontal</enum>
-            </property>
-            <property name="sizeHint" stdset="0">
-             <size>
-              <width>40</width>
-              <height>20</height>
-             </size>
-            </property>
-           </spacer>
-          </item>
-          <item>
-           <widget class="QPushButton" name="pm_add">
-            <property name="text">
-             <string>Add</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QPushButton" name="pm_rename">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="text">
-             <string>Rename</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QPushButton" name="pm_remove">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="text">
-             <string>Remove</string>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
-       </layout>
-      </widget>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>20</width>
+         <height>40</height>
+        </size>
+       </property>
+      </spacer>
      </item>
      <item>
       <widget class="QLabel" name="label_disable_info">