Refactors and name corrections.

Fixes and Corrections to DMA Engine
Add Swizzle Parameters to the DMA engine
2019-05-01 15:31:39 -04:00 · 2019-04-23 15:28:18 -04:00 · 2019-04-23 11:21:00 -04:00 · 2019-04-23 08:44:52 -04:00 · 2019-04-23 08:02:24 -04:00 · 2019-04-22 19:27:36 -04:00
94 changed files with 1009 additions and 1504 deletions
@@ -1,3 +1,3 @@
 #!/bin/bash -ex
 mkdir "$HOME/.ccache" || true
-docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.travis/linux-mingw/docker.sh
+docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache ubuntu:18.04 /bin/bash -ex /yuzu/.travis/linux-mingw/docker.sh
@@ -1,3 +1,3 @@
 #!/bin/sh -ex

-docker pull yuzuemu/build-environments:linux-mingw
+docker pull ubuntu:18.04
@@ -1,6 +1,16 @@
 #!/bin/bash -ex

 cd /yuzu
+MINGW_PACKAGES="sdl2-mingw-w64 qt5base-mingw-w64 qt5tools-mingw-w64 libsamplerate-mingw-w64 qt5multimedia-mingw-w64"
+apt-get update
+apt-get install -y gpg wget git python3-pip python ccache g++-mingw-w64-x86-64 gcc-mingw-w64-x86-64 mingw-w64-tools cmake
+echo 'deb http://ppa.launchpad.net/tobydox/mingw-w64/ubuntu bionic main ' > /etc/apt/sources.list.d/extras.list
+apt-key adv --keyserver keyserver.ubuntu.com --recv '72931B477E22FEFD47F8DECE02FE5F12ADDE29B2'
+apt-get update
+apt-get install -y ${MINGW_PACKAGES}
+
+# fix a problem in current MinGW headers
+wget -q https://raw.githubusercontent.com/Alexpux/mingw-w64/d0d7f784833bbb0b2d279310ddc6afb52fe47a46/mingw-w64-headers/crt/errno.h -O /usr/x86_64-w64-mingw32/include/errno.h
 # override Travis CI unreasonable ccache size
 echo 'max_size = 3.0G' > "$HOME/.ccache/ccache.conf"

@@ -1,4 +1,4 @@
 #!/bin/bash -ex

 mkdir -p "$HOME/.ccache"
-docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh
@@ -1,3 +1,3 @@
 #!/bin/sh -ex

-docker pull yuzuemu/build-environments:linux-fresh
+docker pull ubuntu:18.04
@@ -1,5 +1,8 @@
 #!/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 qtwebengine5-dev wget cmake ninja-build ccache
+
 cd /yuzu

 mkdir build && cd build
@@ -19,6 +19,18 @@ $(brew --prefix)/opt/qt5/bin/macdeployqt "${REV_NAME}/yuzu.app" -executable="${R
 # move libs into folder for deployment
 macpack "${REV_NAME}/yuzu-cmd" -d "libs"

+# Make the yuzu.app application launch a debugging terminal.
+# Store away the actual binary
+mv ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu-bin
+
+cat > ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu <<EOL
+#!/usr/bin/env bash
+cd "\`dirname "\$0"\`"
+chmod +x yuzu-bin
+open yuzu-bin --args "\$@"
+EOL
+# Content that will serve as the launching script for yuzu (within the .app folder)
+
 # Make the launching script executable
 chmod +x ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu

@@ -19,7 +19,7 @@ set(BUILD_VERSION "0")
 if (BUILD_REPOSITORY)
  # regex capture the string nightly or canary into CMAKE_MATCH_1
  string(REGEX MATCH "yuzu-emu/yuzu-?(.*)" OUTVAR ${BUILD_REPOSITORY})
-  if ("${CMAKE_MATCH_COUNT}" GREATER 0)
+  if (${CMAKE_MATCH_COUNT} GREATER 0)
    # capitalize the first letter of each word in the repo name.
    string(REPLACE "-" ";" REPO_NAME_LIST ${CMAKE_MATCH_1})
    foreach(WORD ${REPO_NAME_LIST})
@@ -18,9 +18,6 @@ if (MSVC)
    # Avoid windows.h from including some usually unused libs like winsocks.h, since this might cause some redefinition errors.
    add_definitions(-DWIN32_LEAN_AND_MEAN)

-    # Ensure that projects build with Unicode support.
-    add_definitions(-DUNICODE -D_UNICODE)
-
    # /W3 - Level 3 warnings
    # /MP - Multi-threaded compilation
    # /Zi - Output debugging information
@@ -88,10 +88,6 @@ add_library(core STATIC
    file_sys/vfs_vector.h
    file_sys/xts_archive.cpp
    file_sys/xts_archive.h
-    frontend/applets/error.cpp
-    frontend/applets/error.h
-    frontend/applets/general_frontend.cpp
-    frontend/applets/general_frontend.h
    frontend/applets/profile_select.cpp
    frontend/applets/profile_select.h
    frontend/applets/software_keyboard.cpp
@@ -181,14 +177,12 @@ add_library(core STATIC
    hle/service/am/applet_oe.h
    hle/service/am/applets/applets.cpp
    hle/service/am/applets/applets.h
-    hle/service/am/applets/error.cpp
-    hle/service/am/applets/error.h
-    hle/service/am/applets/general_backend.cpp
-    hle/service/am/applets/general_backend.h
    hle/service/am/applets/profile_select.cpp
    hle/service/am/applets/profile_select.h
    hle/service/am/applets/software_keyboard.cpp
    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
@@ -18,18 +18,13 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/frontend/applets/error.h"
-#include "core/frontend/applets/general_frontend.h"
-#include "core/frontend/applets/profile_select.h"
-#include "core/frontend/applets/software_keyboard.h"
-#include "core/frontend/applets/web_browser.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/am/applets/software_keyboard.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
@@ -115,7 +110,12 @@ struct System::Impl {
            content_provider = std::make_unique<FileSys::ContentProviderUnion>();

        /// Create default implementations of applets if one is not provided.
-        applet_manager.SetDefaultAppletsIfMissing();
+        if (profile_selector == nullptr)
+            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>();

        telemetry_session = std::make_unique<Core::TelemetrySession>();
        service_manager = std::make_shared<Service::SM::ServiceManager>();
@@ -223,7 +223,9 @@ struct System::Impl {
        app_loader.reset();

        // Clear all applets
-        applet_manager.ClearAll();
+        profile_selector.reset();
+        software_keyboard.reset();
+        web_browser.reset();

        LOG_DEBUG(Core, "Shutdown OK");
    }
@@ -262,7 +264,9 @@ struct System::Impl {
    std::unique_ptr<FileSys::CheatEngine> cheat_engine;

    /// Frontend applets
-    Service::AM::Applets::AppletManager applet_manager;
+    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;
@@ -472,20 +476,20 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
    return impl->virtual_filesystem;
 }

-void System::SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set) {
-    impl->applet_manager.SetAppletFrontendSet(std::move(set));
+void System::SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet) {
+    impl->profile_selector = std::move(applet);
 }

-void System::SetDefaultAppletFrontendSet() {
-    impl->applet_manager.SetDefaultAppletFrontendSet();
+const Frontend::ProfileSelectApplet& System::GetProfileSelector() const {
+    return *impl->profile_selector;
 }

-Service::AM::Applets::AppletManager& System::GetAppletManager() {
-    return impl->applet_manager;
+void System::SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet) {
+    impl->software_keyboard = std::move(applet);
 }

-const Service::AM::Applets::AppletManager& System::GetAppletManager() const {
-    return impl->applet_manager;
+const Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
+    return *impl->software_keyboard;
 }

 void System::SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider) {
@@ -509,6 +513,18 @@ void System::ClearContentProvider(FileSys::ContentProviderUnionSlot slot) {
    impl->content_provider->ClearSlot(slot);
 }

+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);
 }
@@ -14,6 +14,9 @@

 namespace Core::Frontend {
 class EmuWindow;
+class ProfileSelectApplet;
+class SoftwareKeyboardApplet;
+class WebBrowserApplet;
 } // namespace Core::Frontend

 namespace FileSys {
@@ -35,18 +38,9 @@ class AppLoader;
 enum class ResultStatus : u16;
 } // namespace Loader

-namespace Service {
-
-namespace AM::Applets {
-struct AppletFrontendSet;
-class AppletManager;
-} // namespace AM::Applets
-
-namespace SM {
+namespace Service::SM {
 class ServiceManager;
-} // namespace SM
-
-} // namespace Service
+} // namespace Service::SM

 namespace Tegra {
 class DebugContext;
@@ -266,13 +260,18 @@ public:
    void RegisterCheatList(const std::vector<FileSys::CheatList>& list, const std::string& build_id,
                           VAddr code_region_start, VAddr code_region_end);

-    void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
+    void SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet);

-    void SetDefaultAppletFrontendSet();
+    const Frontend::ProfileSelectApplet& GetProfileSelector() const;

-    Service::AM::Applets::AppletManager& GetAppletManager();
+    void SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet);

-    const Service::AM::Applets::AppletManager& GetAppletManager() const;
+    const Frontend::SoftwareKeyboardApplet& GetSoftwareKeyboard() const;
+
+    void SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet);
+
+    Frontend::WebBrowserApplet& GetWebBrowser();
+    const Frontend::WebBrowserApplet& GetWebBrowser() const;

    void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);

@@ -1,34 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/frontend/applets/error.h"
-
-namespace Core::Frontend {
-
-ErrorApplet::~ErrorApplet() = default;
-
-void DefaultErrorApplet::ShowError(ResultCode error, std::function<void()> finished) const {
-    LOG_CRITICAL(Service_Fatal, "Application requested error display: {:04}-{:04} (raw={:08X})",
-                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
-}
-
-void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                                std::function<void()> finished) const {
-    LOG_CRITICAL(
-        Service_Fatal,
-        "Application requested error display: {:04X}-{:04X} (raw={:08X}) with timestamp={:016X}",
-        static_cast<u32>(error.module.Value()), error.description.Value(), error.raw, time.count());
-}
-
-void DefaultErrorApplet::ShowCustomErrorText(ResultCode error, std::string main_text,
-                                             std::string detail_text,
-                                             std::function<void()> finished) const {
-    LOG_CRITICAL(Service_Fatal,
-                 "Application requested custom error with error_code={:04X}-{:04X} (raw={:08X})",
-                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
-    LOG_CRITICAL(Service_Fatal, "    Main Text: {}", main_text);
-    LOG_CRITICAL(Service_Fatal, "    Detail Text: {}", detail_text);
-}
-
-} // namespace Core::Frontend
@@ -1,37 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <chrono>
-#include <functional>
-
-#include "core/hle/result.h"
-
-namespace Core::Frontend {
-
-class ErrorApplet {
-public:
-    virtual ~ErrorApplet();
-
-    virtual void ShowError(ResultCode error, std::function<void()> finished) const = 0;
-
-    virtual void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                        std::function<void()> finished) const = 0;
-
-    virtual void ShowCustomErrorText(ResultCode error, std::string dialog_text,
-                                     std::string fullscreen_text,
-                                     std::function<void()> finished) const = 0;
-};
-
-class DefaultErrorApplet final : public ErrorApplet {
-public:
-    void ShowError(ResultCode error, std::function<void()> finished) const override;
-    void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                std::function<void()> finished) const override;
-    void ShowCustomErrorText(ResultCode error, std::string main_text, std::string detail_text,
-                             std::function<void()> finished) const override;
-};
-
-} // namespace Core::Frontend
@@ -1,27 +0,0 @@
-// Copyright 2019 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/general_frontend.h"
-
-namespace Core::Frontend {
-
-PhotoViewerApplet::~PhotoViewerApplet() = default;
-
-DefaultPhotoViewerApplet::~DefaultPhotoViewerApplet() {}
-
-void DefaultPhotoViewerApplet::ShowPhotosForApplication(u64 title_id,
-                                                        std::function<void()> finished) const {
-    LOG_INFO(Service_AM,
-             "Application requested frontend to display stored photos for title_id={:016X}",
-             title_id);
-    finished();
-}
-
-void DefaultPhotoViewerApplet::ShowAllPhotos(std::function<void()> finished) const {
-    LOG_INFO(Service_AM, "Application requested frontend to display all stored photos.");
-    finished();
-}
-
-} // namespace Core::Frontend
@@ -1,28 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-#include "common/common_types.h"
-
-namespace Core::Frontend {
-
-class PhotoViewerApplet {
-public:
-    virtual ~PhotoViewerApplet();
-
-    virtual void ShowPhotosForApplication(u64 title_id, std::function<void()> finished) const = 0;
-    virtual void ShowAllPhotos(std::function<void()> finished) const = 0;
-};
-
-class DefaultPhotoViewerApplet final : public PhotoViewerApplet {
-public:
-    ~DefaultPhotoViewerApplet() override;
-
-    void ShowPhotosForApplication(u64 title_id, std::function<void()> finished) const override;
-    void ShowAllPhotos(std::function<void()> finished) const override;
-};
-
-} // namespace Core::Frontend
@@ -46,7 +46,8 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_

    bool resume = true;

-    if (thread->GetStatus() == ThreadStatus::WaitSynch ||
+    if (thread->GetStatus() == ThreadStatus::WaitSynchAny ||
+        thread->GetStatus() == ThreadStatus::WaitSynchAll ||
        thread->GetStatus() == ThreadStatus::WaitHLEEvent) {
        // Remove the thread from each of its waiting objects' waitlists
        for (const auto& object : thread->GetWaitObjects()) {
@@ -147,7 +147,8 @@ void Process::PrepareForTermination() {
                continue;

            // TODO(Subv): When are the other running/ready threads terminated?
-            ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynch,
+            ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynchAny ||
+                           thread->GetStatus() == ThreadStatus::WaitSynchAll,
                       "Exiting processes with non-waiting threads is currently unimplemented");

            thread->Stop();
@@ -241,8 +242,7 @@ void Process::LoadModule(CodeSet module_, VAddr base_addr) {
 }

 Process::Process(Core::System& system)
-    : WaitObject{system.Kernel()}, vm_manager{system},
-      address_arbiter{system}, mutex{system}, system{system} {}
+    : WaitObject{system.Kernel()}, address_arbiter{system}, mutex{system}, system{system} {}

 Process::~Process() = default;

@@ -424,7 +424,7 @@ static ResultCode GetProcessId(Core::System& system, u64* process_id, Handle han
 /// Default thread wakeup callback for WaitSynchronization
 static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
                                        SharedPtr<WaitObject> object, std::size_t index) {
-    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynch);
+    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);

    if (reason == ThreadWakeupReason::Timeout) {
        thread->SetWaitSynchronizationResult(RESULT_TIMEOUT);
@@ -502,7 +502,7 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
    }

    thread->SetWaitObjects(std::move(objects));
-    thread->SetStatus(ThreadStatus::WaitSynch);
+    thread->SetStatus(ThreadStatus::WaitSynchAny);

    // Create an event to wake the thread up after the specified nanosecond delay has passed
    thread->WakeAfterDelay(nano_seconds);
@@ -518,14 +518,16 @@ static ResultCode CancelSynchronization(Core::System& system, Handle thread_hand
    LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);

    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
                  thread_handle);
        return ERR_INVALID_HANDLE;
    }

-    thread->CancelWait();
+    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);
+    thread->SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
+    thread->ResumeFromWait();
    return RESULT_SUCCESS;
 }

@@ -101,7 +101,8 @@ void Thread::ResumeFromWait() {
    ASSERT_MSG(wait_objects.empty(), "Thread is waking up while waiting for objects");

    switch (status) {
-    case ThreadStatus::WaitSynch:
+    case ThreadStatus::WaitSynchAll:
+    case ThreadStatus::WaitSynchAny:
    case ThreadStatus::WaitHLEEvent:
    case ThreadStatus::WaitSleep:
    case ThreadStatus::WaitIPC:
@@ -141,12 +142,6 @@ void Thread::ResumeFromWait() {
    ChangeScheduler();
 }

-void Thread::CancelWait() {
-    ASSERT(GetStatus() == ThreadStatus::WaitSynch);
-    SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
-    ResumeFromWait();
-}
-
 /**
 * Resets a thread context, making it ready to be scheduled and run by the CPU
 * @param context Thread context to reset
@@ -49,7 +49,8 @@ enum class ThreadStatus {
    WaitHLEEvent, ///< Waiting for hle event to finish
    WaitSleep,    ///< Waiting due to a SleepThread SVC
    WaitIPC,      ///< Waiting for the reply from an IPC request
-    WaitSynch,    ///< Waiting due to WaitSynchronization
+    WaitSynchAny, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false
+    WaitSynchAll, ///< Waiting due to WaitSynchronizationN with wait_all = true
    WaitMutex,    ///< Waiting due to an ArbitrateLock svc
    WaitCondVar,  ///< Waiting due to an WaitProcessWideKey svc
    WaitArb,      ///< Waiting due to a SignalToAddress/WaitForAddress svc
@@ -168,17 +169,11 @@ public:
        return tls_memory;
    }

-    /// Resumes a thread from waiting
+    /**
+     * Resumes a thread from waiting
+     */
    void ResumeFromWait();

-    /// Cancels a waiting operation that this thread may or may not be within.
-    ///
-    /// When the thread is within a waiting state, this will set the thread's
-    /// waiting result to signal a canceled wait. The function will then resume
-    /// this thread.
-    ///
-    void CancelWait();
-
    /**
     * Schedules an event to wake up the specified thread after the specified delay
     * @param nanoseconds The time this thread will be allowed to sleep for
@@ -189,27 +184,24 @@ public:
    void CancelWakeupTimer();

    /**
-     * Sets the result after the thread awakens (from svcWaitSynchronization)
+     * Sets the result after the thread awakens (from either WaitSynchronization SVC)
     * @param result Value to set to the returned result
     */
    void SetWaitSynchronizationResult(ResultCode result);

    /**
-     * Sets the output parameter value after the thread awakens (from svcWaitSynchronization)
+     * Sets the output parameter value after the thread awakens (from WaitSynchronizationN SVC only)
     * @param output Value to set to the output parameter
     */
    void SetWaitSynchronizationOutput(s32 output);

    /**
     * Retrieves the index that this particular object occupies in the list of objects
-     * that the thread passed to WaitSynchronization, starting the search from the last element.
-     *
-     * It is used to set the output index of WaitSynchronization when the thread is awakened.
-     *
+     * that the thread passed to WaitSynchronizationN, starting the search from the last element.
+     * It is used to set the output value of WaitSynchronizationN when the thread is awakened.
     * When a thread wakes up due to an object signal, the kernel will use the index of the last
     * matching object in the wait objects list in case of having multiple instances of the same
     * object in the list.
-     *
     * @param object Object to query the index of.
     */
    s32 GetWaitObjectIndex(const WaitObject* object) const;
@@ -246,9 +238,13 @@ public:
     */
    VAddr GetCommandBufferAddress() const;

-    /// Returns whether this thread is waiting on objects from a WaitSynchronization call.
-    bool IsSleepingOnWait() const {
-        return status == ThreadStatus::WaitSynch;
+    /**
+     * Returns whether this thread is waiting for all the objects in
+     * its wait list to become ready, as a result of a WaitSynchronizationN call
+     * with wait_all = true.
+     */
+    bool IsSleepingOnWaitAll() const {
+        return status == ThreadStatus::WaitSynchAll;
    }

    ThreadContext& GetContext() {
@@ -422,7 +418,7 @@ private:
    Process* owner_process;

    /// Objects that the thread is waiting on, in the same order as they were
-    /// passed to WaitSynchronization.
+    /// passed to WaitSynchronization1/N.
    ThreadWaitObjects wait_objects;

    /// List of threads that are waiting for a mutex that is held by this thread.
@@ -445,7 +441,7 @@ private:
    Handle callback_handle = 0;

    /// Callback that will be invoked when the thread is resumed from a waiting state. If the thread
-    /// was waiting via WaitSynchronization then the object will be the last object that became
+    /// was waiting via WaitSynchronizationN then the object will be the last object that became
    /// available. In case of a timeout, the object will be nullptr.
    WakeupCallback wakeup_callback;

@@ -62,7 +62,7 @@ bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
    return true;
 }

-VMManager::VMManager(Core::System& system) : system{system} {
+VMManager::VMManager() {
    // Default to assuming a 39-bit address space. This way we have a sane
    // starting point with executables that don't provide metadata.
    Reset(FileSys::ProgramAddressSpaceType::Is39Bit);
@@ -111,6 +111,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
    VirtualMemoryArea& final_vma = vma_handle->second;
    ASSERT(final_vma.size == size);

+    auto& system = Core::System::GetInstance();
    system.ArmInterface(0).MapBackingMemory(target, size, block->data() + offset,
                                            VMAPermission::ReadWriteExecute);
    system.ArmInterface(1).MapBackingMemory(target, size, block->data() + offset,
@@ -139,6 +140,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
    VirtualMemoryArea& final_vma = vma_handle->second;
    ASSERT(final_vma.size == size);

+    auto& system = Core::System::GetInstance();
    system.ArmInterface(0).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
    system.ArmInterface(1).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
    system.ArmInterface(2).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
@@ -221,6 +223,7 @@ ResultCode VMManager::UnmapRange(VAddr target, u64 size) {

    ASSERT(FindVMA(target)->second.size >= size);

+    auto& system = Core::System::GetInstance();
    system.ArmInterface(0).UnmapMemory(target, size);
    system.ArmInterface(1).UnmapMemory(target, size);
    system.ArmInterface(2).UnmapMemory(target, size);
@@ -373,7 +376,7 @@ ResultCode VMManager::UnmapCodeMemory(VAddr dst_address, VAddr src_address, u64
    Reprotect(src_vma_iter, VMAPermission::ReadWrite);

    if (dst_memory_state == MemoryState::ModuleCode) {
-        system.InvalidateCpuInstructionCaches();
+        Core::System::GetInstance().InvalidateCpuInstructionCaches();
    }

    return unmap_result;
@@ -14,10 +14,6 @@
 #include "core/hle/result.h"
 #include "core/memory.h"

-namespace Core {
-class System;
-}
-
 namespace FileSys {
 enum class ProgramAddressSpaceType : u8;
 }
@@ -325,7 +321,7 @@ class VMManager final {
 public:
    using VMAHandle = VMAMap::const_iterator;

-    explicit VMManager(Core::System& system);
+    VMManager();
    ~VMManager();

    /// Clears the address space map, re-initializing with a single free area.
@@ -716,7 +712,5 @@ private:
    // The end of the currently allocated heap. This is not an inclusive
    // end of the range. This is essentially 'base_address + current_size'.
    VAddr heap_end = 0;
-
-    Core::System& system;
 };
 } // namespace Kernel
@@ -38,7 +38,8 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
        const ThreadStatus thread_status = thread->GetStatus();

        // The list of waiting threads must not contain threads that are not waiting to be awakened.
-        ASSERT_MSG(thread_status == ThreadStatus::WaitSynch ||
+        ASSERT_MSG(thread_status == ThreadStatus::WaitSynchAny ||
+                       thread_status == ThreadStatus::WaitSynchAll ||
                       thread_status == ThreadStatus::WaitHLEEvent,
                   "Inconsistent thread statuses in waiting_threads");

@@ -48,10 +49,10 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
        if (ShouldWait(thread.get()))
            continue;

-        // A thread is ready to run if it's either in ThreadStatus::WaitSynch
-        // and the rest of the objects it is waiting on are ready.
+        // A thread is ready to run if it's either in ThreadStatus::WaitSynchAny or
+        // in ThreadStatus::WaitSynchAll and the rest of the objects it is waiting on are ready.
        bool ready_to_run = true;
-        if (thread_status == ThreadStatus::WaitSynch) {
+        if (thread_status == ThreadStatus::WaitSynchAll) {
            ready_to_run = thread->AllWaitObjectsReady();
        }

@@ -67,35 +68,33 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
 void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
    ASSERT(!ShouldWait(thread.get()));

-    if (!thread) {
+    if (!thread)
        return;
-    }

-    if (thread->IsSleepingOnWait()) {
+    if (!thread->IsSleepingOnWaitAll()) {
+        Acquire(thread.get());
+    } else {
        for (const auto& object : thread->GetWaitObjects()) {
            ASSERT(!object->ShouldWait(thread.get()));
            object->Acquire(thread.get());
        }
-    } else {
-        Acquire(thread.get());
    }

    const std::size_t index = thread->GetWaitObjectIndex(this);

-    for (const auto& object : thread->GetWaitObjects()) {
+    for (const auto& object : thread->GetWaitObjects())
        object->RemoveWaitingThread(thread.get());
-    }
    thread->ClearWaitObjects();

    thread->CancelWakeupTimer();

    bool resume = true;
-    if (thread->HasWakeupCallback()) {
+
+    if (thread->HasWakeupCallback())
        resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Signal, thread, this, index);
-    }
-    if (resume) {
+
+    if (resume)
        thread->ResumeFromWait();
-    }
 }

 void WaitObject::WakeupAllWaitingThreads() {
@@ -22,6 +22,7 @@
 #include "core/hle/service/am/applets/applets.h"
 #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"
@@ -41,6 +42,12 @@ 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;

 struct LaunchParameters {
@@ -879,16 +886,30 @@ ILibraryAppletCreator::ILibraryAppletCreator() : ServiceFramework("ILibraryApple

 ILibraryAppletCreator::~ILibraryAppletCreator() = default;

+static std::shared_ptr<Applets::Applet> GetAppletFromId(AppletId id) {
+    switch (id) {
+    case AppletId::ProfileSelect:
+        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));
+        return std::make_shared<Applets::StubApplet>();
+    }
+}
+
 void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    const auto applet_id = rp.PopRaw<Applets::AppletId>();
+    const auto applet_id = rp.PopRaw<AppletId>();
    const auto applet_mode = rp.PopRaw<u32>();

    LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}",
              static_cast<u32>(applet_id), applet_mode);

-    const auto& applet_manager{Core::System::GetInstance().GetAppletManager()};
-    const auto applet = applet_manager.GetApplet(applet_id);
+    const auto applet = GetAppletFromId(applet_id);

    if (applet == nullptr) {
        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", static_cast<u32>(applet_id));
@@ -5,21 +5,11 @@
 #include <cstring>
 #include "common/assert.h"
 #include "core/core.h"
-#include "core/frontend/applets/error.h"
-#include "core/frontend/applets/general_frontend.h"
-#include "core/frontend/applets/profile_select.h"
-#include "core/frontend/applets/software_keyboard.h"
-#include "core/frontend/applets/web_browser.h"
 #include "core/hle/kernel/readable_event.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"
-#include "core/hle/service/am/applets/error.h"
-#include "core/hle/service/am/applets/general_backend.h"
-#include "core/hle/service/am/applets/profile_select.h"
-#include "core/hle/service/am/applets/software_keyboard.h"
-#include "core/hle/service/am/applets/web_browser.h"

 namespace Service::AM::Applets {

@@ -121,76 +111,4 @@ void Applet::Initialize() {
    initialized = true;
 }

-AppletManager::AppletManager() = default;
-
-AppletManager::~AppletManager() = default;
-
-void AppletManager::SetAppletFrontendSet(AppletFrontendSet set) {
-    if (set.error != nullptr)
-        frontend.error = std::move(set.error);
-    if (set.photo_viewer != nullptr)
-        frontend.photo_viewer = std::move(set.photo_viewer);
-    if (set.profile_select != nullptr)
-        frontend.profile_select = std::move(set.profile_select);
-    if (set.software_keyboard != nullptr)
-        frontend.software_keyboard = std::move(set.software_keyboard);
-    if (set.web_browser != nullptr)
-        frontend.web_browser = std::move(set.web_browser);
-}
-
-void AppletManager::SetDefaultAppletFrontendSet() {
-    frontend.error = std::make_unique<Core::Frontend::DefaultErrorApplet>();
-    frontend.photo_viewer = std::make_unique<Core::Frontend::DefaultPhotoViewerApplet>();
-    frontend.profile_select = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
-    frontend.software_keyboard = std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
-    frontend.web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
-}
-
-void AppletManager::SetDefaultAppletsIfMissing() {
-    if (frontend.error == nullptr) {
-        frontend.error = std::make_unique<Core::Frontend::DefaultErrorApplet>();
-    }
-
-    if (frontend.photo_viewer == nullptr) {
-        frontend.photo_viewer = std::make_unique<Core::Frontend::DefaultPhotoViewerApplet>();
-    }
-
-    if (frontend.profile_select == nullptr) {
-        frontend.profile_select = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
-    }
-
-    if (frontend.software_keyboard == nullptr) {
-        frontend.software_keyboard =
-            std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
-    }
-
-    if (frontend.web_browser == nullptr) {
-        frontend.web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
-    }
-}
-
-void AppletManager::ClearAll() {
-    frontend = {};
-}
-
-std::shared_ptr<Applet> AppletManager::GetApplet(AppletId id) const {
-    switch (id) {
-    case AppletId::Error:
-        return std::make_shared<Error>(*frontend.error);
-    case AppletId::ProfileSelect:
-        return std::make_shared<ProfileSelect>(*frontend.profile_select);
-    case AppletId::SoftwareKeyboard:
-        return std::make_shared<SoftwareKeyboard>(*frontend.software_keyboard);
-    case AppletId::PhotoViewer:
-        return std::make_shared<PhotoViewer>(*frontend.photo_viewer);
-    case AppletId::LibAppletOff:
-        return std::make_shared<WebBrowser>(*frontend.web_browser);
-    default:
-        UNIMPLEMENTED_MSG(
-            "No backend implementation exists for applet_id={:02X}! Falling back to stub applet.",
-            static_cast<u8>(id));
-        return std::make_shared<StubApplet>();
-    }
-}
-
 } // namespace Service::AM::Applets
@@ -12,43 +12,12 @@

 union ResultCode;

-namespace Core::Frontend {
-class ErrorApplet;
-class PhotoViewerApplet;
-class ProfileSelectApplet;
-class SoftwareKeyboardApplet;
-class WebBrowserApplet;
-} // namespace Core::Frontend
-
 namespace Service::AM {

 class IStorage;

 namespace Applets {

-enum class AppletId : u32 {
-    OverlayDisplay = 0x02,
-    QLaunch = 0x03,
-    Starter = 0x04,
-    Auth = 0x0A,
-    Cabinet = 0x0B,
-    Controller = 0x0C,
-    DataErase = 0x0D,
-    Error = 0x0E,
-    NetConnect = 0x0F,
-    ProfileSelect = 0x10,
-    SoftwareKeyboard = 0x11,
-    MiiEdit = 0x12,
-    LibAppletWeb = 0x13,
-    LibAppletShop = 0x14,
-    PhotoViewer = 0x15,
-    Settings = 0x16,
-    LibAppletOff = 0x17,
-    LibAppletWhitelisted = 0x18,
-    LibAppletAuth = 0x19,
-    MyPage = 0x1A,
-};
-
 class AppletDataBroker final {
 public:
    AppletDataBroker();
@@ -136,29 +105,5 @@ protected:
    bool initialized = false;
 };

-struct AppletFrontendSet {
-    std::unique_ptr<Core::Frontend::ErrorApplet> error;
-    std::unique_ptr<Core::Frontend::PhotoViewerApplet> photo_viewer;
-    std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_select;
-    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
-    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;
-};
-
-class AppletManager {
-public:
-    AppletManager();
-    ~AppletManager();
-
-    void SetAppletFrontendSet(AppletFrontendSet set);
-    void SetDefaultAppletFrontendSet();
-    void SetDefaultAppletsIfMissing();
-    void ClearAll();
-
-    std::shared_ptr<Applet> GetApplet(AppletId id) const;
-
-private:
-    AppletFrontendSet frontend;
-};
-
 } // namespace Applets
 } // namespace Service::AM
@@ -1,182 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <array>
-#include <cstring>
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/frontend/applets/error.h"
-#include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/error.h"
-
-namespace Service::AM::Applets {
-
-#pragma pack(push, 4)
-struct ShowError {
-    u8 mode;
-    bool jump;
-    INSERT_PADDING_BYTES(4);
-    bool use_64bit_error_code;
-    INSERT_PADDING_BYTES(1);
-    u64 error_code_64;
-    u32 error_code_32;
-};
-static_assert(sizeof(ShowError) == 0x14, "ShowError has incorrect size.");
-#pragma pack(pop)
-
-struct ShowErrorRecord {
-    u8 mode;
-    bool jump;
-    INSERT_PADDING_BYTES(6);
-    u64 error_code_64;
-    u64 posix_time;
-};
-static_assert(sizeof(ShowErrorRecord) == 0x18, "ShowErrorRecord has incorrect size.");
-
-struct SystemErrorArg {
-    u8 mode;
-    bool jump;
-    INSERT_PADDING_BYTES(6);
-    u64 error_code_64;
-    std::array<char, 8> language_code;
-    std::array<char, 0x800> main_text;
-    std::array<char, 0x800> detail_text;
-};
-static_assert(sizeof(SystemErrorArg) == 0x1018, "SystemErrorArg has incorrect size.");
-
-struct ApplicationErrorArg {
-    u8 mode;
-    bool jump;
-    INSERT_PADDING_BYTES(6);
-    u32 error_code;
-    std::array<char, 8> language_code;
-    std::array<char, 0x800> main_text;
-    std::array<char, 0x800> detail_text;
-};
-static_assert(sizeof(ApplicationErrorArg) == 0x1014, "ApplicationErrorArg has incorrect size.");
-
-union Error::ErrorArguments {
-    ShowError error;
-    ShowErrorRecord error_record;
-    SystemErrorArg system_error;
-    ApplicationErrorArg application_error;
-};
-
-namespace {
-template <typename T>
-void CopyArgumentData(const std::vector<u8>& data, T& variable) {
-    ASSERT(data.size() >= sizeof(T));
-    std::memcpy(&variable, data.data(), sizeof(T));
-}
-
-ResultCode Decode64BitError(u64 error) {
-    const auto description = (error >> 32) & 0x1FFF;
-    auto module = error & 0x3FF;
-    if (module >= 2000)
-        module -= 2000;
-    module &= 0x1FF;
-    return {static_cast<ErrorModule>(module), static_cast<u32>(description)};
-}
-
-} // Anonymous namespace
-
-Error::Error(const Core::Frontend::ErrorApplet& frontend) : frontend(frontend) {}
-
-Error::~Error() = default;
-
-void Error::Initialize() {
-    Applet::Initialize();
-    args = std::make_unique<ErrorArguments>();
-    complete = false;
-
-    const auto storage = broker.PopNormalDataToApplet();
-    ASSERT(storage != nullptr);
-    const auto data = storage->GetData();
-
-    ASSERT(!data.empty());
-    std::memcpy(&mode, data.data(), sizeof(ErrorAppletMode));
-
-    switch (mode) {
-    case ErrorAppletMode::ShowError:
-        CopyArgumentData(data, args->error);
-        if (args->error.use_64bit_error_code) {
-            error_code = Decode64BitError(args->error.error_code_64);
-        } else {
-            error_code = ResultCode(args->error.error_code_32);
-        }
-        break;
-    case ErrorAppletMode::ShowSystemError:
-        CopyArgumentData(data, args->system_error);
-        error_code = ResultCode(Decode64BitError(args->system_error.error_code_64));
-        break;
-    case ErrorAppletMode::ShowApplicationError:
-        CopyArgumentData(data, args->application_error);
-        error_code = ResultCode(args->application_error.error_code);
-        break;
-    case ErrorAppletMode::ShowErrorRecord:
-        CopyArgumentData(data, args->error_record);
-        error_code = Decode64BitError(args->error_record.error_code_64);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
-    }
-}
-
-bool Error::TransactionComplete() const {
-    return complete;
-}
-
-ResultCode Error::GetStatus() const {
-    return RESULT_SUCCESS;
-}
-
-void Error::ExecuteInteractive() {
-    UNREACHABLE_MSG("Unexpected interactive applet data!");
-}
-
-void Error::Execute() {
-    if (complete) {
-        return;
-    }
-
-    const auto callback = [this] { DisplayCompleted(); };
-
-    switch (mode) {
-    case ErrorAppletMode::ShowError:
-        frontend.ShowError(error_code, callback);
-        break;
-    case ErrorAppletMode::ShowSystemError:
-    case ErrorAppletMode::ShowApplicationError: {
-        const auto system = mode == ErrorAppletMode::ShowSystemError;
-        const auto& main_text =
-            system ? args->system_error.main_text : args->application_error.main_text;
-        const auto& detail_text =
-            system ? args->system_error.detail_text : args->application_error.detail_text;
-
-        frontend.ShowCustomErrorText(
-            error_code,
-            Common::StringFromFixedZeroTerminatedBuffer(main_text.data(), main_text.size()),
-            Common::StringFromFixedZeroTerminatedBuffer(detail_text.data(), detail_text.size()),
-            callback);
-        break;
-    }
-    case ErrorAppletMode::ShowErrorRecord:
-        frontend.ShowErrorWithTimestamp(
-            error_code, std::chrono::seconds{args->error_record.posix_time}, callback);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
-        DisplayCompleted();
-    }
-}
-
-void Error::DisplayCompleted() {
-    complete = true;
-    broker.PushNormalDataFromApplet(IStorage{{}});
-    broker.SignalStateChanged();
-}
-
-} // namespace Service::AM::Applets
@@ -1,47 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/result.h"
-#include "core/hle/service/am/applets/applets.h"
-
-namespace Service::AM::Applets {
-
-enum class ErrorAppletMode : u8 {
-    ShowError = 0,
-    ShowSystemError = 1,
-    ShowApplicationError = 2,
-    ShowEula = 3,
-    ShowErrorPctl = 4,
-    ShowErrorRecord = 5,
-    ShowUpdateEula = 8,
-};
-
-class Error final : public Applet {
-public:
-    explicit Error(const Core::Frontend::ErrorApplet& frontend);
-    ~Error() override;
-
-    void Initialize() override;
-
-    bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
-    void ExecuteInteractive() override;
-    void Execute() override;
-
-    void DisplayCompleted();
-
-private:
-    union ErrorArguments;
-
-    const Core::Frontend::ErrorApplet& frontend;
-    ResultCode error_code = RESULT_SUCCESS;
-    ErrorAppletMode mode = ErrorAppletMode::ShowError;
-    std::unique_ptr<ErrorArguments> args;
-
-    bool complete = false;
-};
-
-} // namespace Service::AM::Applets
@@ -1,48 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/am/applets/applets.h"
-
-namespace Service::AM::Applets {
-
-enum class PhotoViewerAppletMode : u8 {
-    CurrentApp = 0,
-    AllApps = 1,
-};
-
-class PhotoViewer final : public Applet {
-public:
-    explicit PhotoViewer(const Core::Frontend::PhotoViewerApplet& frontend);
-    ~PhotoViewer() override;
-
-    void Initialize() override;
-    bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
-    void ExecuteInteractive() override;
-    void Execute() override;
-
-    void ViewFinished();
-
-private:
-    const Core::Frontend::PhotoViewerApplet& frontend;
-    bool complete = false;
-    PhotoViewerAppletMode mode = PhotoViewerAppletMode::CurrentApp;
-};
-
-class StubApplet final : public Applet {
-public:
-    StubApplet();
-    ~StubApplet() override;
-
-    void Initialize() override;
-
-    bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
-    void ExecuteInteractive() override;
-    void Execute() override;
-};
-
-} // namespace Service::AM::Applets
@@ -15,9 +15,7 @@ namespace Service::AM::Applets {

 constexpr ResultCode ERR_USER_CANCELLED_SELECTION{ErrorModule::Account, 1};

-ProfileSelect::ProfileSelect(const Core::Frontend::ProfileSelectApplet& frontend)
-    : frontend(frontend) {}
-
+ProfileSelect::ProfileSelect() = default;
 ProfileSelect::~ProfileSelect() = default;

 void ProfileSelect::Initialize() {
@@ -53,6 +51,8 @@ void ProfileSelect::Execute() {
        return;
    }

+    const auto& frontend{Core::System::GetInstance().GetProfileSelector()};
+
    frontend.SelectProfile([this](std::optional<Account::UUID> uuid) { SelectionComplete(uuid); });
 }

@@ -28,7 +28,7 @@ static_assert(sizeof(UserSelectionOutput) == 0x18, "UserSelectionOutput has inco

 class ProfileSelect final : public Applet {
 public:
-    explicit ProfileSelect(const Core::Frontend::ProfileSelectApplet& frontend);
+    ProfileSelect();
    ~ProfileSelect() override;

    void Initialize() override;
@@ -41,8 +41,6 @@ public:
    void SelectionComplete(std::optional<Account::UUID> uuid);

 private:
-    const Core::Frontend::ProfileSelectApplet& frontend;
-
    UserSelectionConfig config;
    bool complete = false;
    ResultCode status = RESULT_SUCCESS;
@@ -39,8 +39,7 @@ static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
    return params;
 }

-SoftwareKeyboard::SoftwareKeyboard(const Core::Frontend::SoftwareKeyboardApplet& frontend)
-    : frontend(frontend) {}
+SoftwareKeyboard::SoftwareKeyboard() = default;

 SoftwareKeyboard::~SoftwareKeyboard() = default;

@@ -91,6 +90,8 @@ void SoftwareKeyboard::ExecuteInteractive() {
    if (status == INTERACTIVE_STATUS_OK) {
        complete = true;
    } else {
+        const auto& frontend{Core::System::GetInstance().GetSoftwareKeyboard()};
+
        std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
        std::memcpy(string.data(), data.data() + 4, string.size() * 2);
        frontend.SendTextCheckDialog(
@@ -105,6 +106,8 @@ void SoftwareKeyboard::Execute() {
        return;
    }

+    const auto& frontend{Core::System::GetInstance().GetSoftwareKeyboard()};
+
    const auto parameters = ConvertToFrontendParameters(config, initial_text);

    frontend.RequestText([this](std::optional<std::u16string> text) { WriteText(text); },
@@ -55,7 +55,7 @@ static_assert(sizeof(KeyboardConfig) == 0x3E0, "KeyboardConfig has incorrect siz

 class SoftwareKeyboard final : public Applet {
 public:
-    explicit SoftwareKeyboard(const Core::Frontend::SoftwareKeyboardApplet& frontend);
+    SoftwareKeyboard();
    ~SoftwareKeyboard() override;

    void Initialize() override;
@@ -68,8 +68,6 @@ public:
    void WriteText(std::optional<std::u16string> text);

 private:
-    const Core::Frontend::SoftwareKeyboardApplet& frontend;
-
    KeyboardConfig config;
    std::u16string initial_text;
    bool complete = false;
@@ -4,15 +4,11 @@

 #include <string>

-#include "common/assert.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
-#include "core/core.h"
-#include "core/frontend/applets/general_frontend.h"
-#include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/general_backend.h"
+#include "core/hle/service/am/applets/stub_applet.h"

 namespace Service::AM::Applets {

@@ -34,55 +30,6 @@ static void LogCurrentStorage(AppletDataBroker& broker, std::string prefix) {
    }
 }

-PhotoViewer::PhotoViewer(const Core::Frontend::PhotoViewerApplet& frontend) : frontend(frontend) {}
-
-PhotoViewer::~PhotoViewer() = default;
-
-void PhotoViewer::Initialize() {
-    Applet::Initialize();
-    complete = false;
-
-    const auto storage = broker.PopNormalDataToApplet();
-    ASSERT(storage != nullptr);
-    const auto data = storage->GetData();
-    ASSERT(!data.empty());
-    mode = static_cast<PhotoViewerAppletMode>(data[0]);
-}
-
-bool PhotoViewer::TransactionComplete() const {
-    return complete;
-}
-
-ResultCode PhotoViewer::GetStatus() const {
-    return RESULT_SUCCESS;
-}
-
-void PhotoViewer::ExecuteInteractive() {
-    UNREACHABLE_MSG("Unexpected interactive applet data.");
-}
-
-void PhotoViewer::Execute() {
-    if (complete)
-        return;
-
-    const auto callback = [this] { ViewFinished(); };
-    switch (mode) {
-    case PhotoViewerAppletMode::CurrentApp:
-        frontend.ShowPhotosForApplication(Core::CurrentProcess()->GetTitleID(), callback);
-        break;
-    case PhotoViewerAppletMode::AllApps:
-        frontend.ShowAllPhotos(callback);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented PhotoViewer applet mode={:02X}!", static_cast<u8>(mode));
-    }
-}
-
-void PhotoViewer::ViewFinished() {
-    broker.PushNormalDataFromApplet(IStorage{{}});
-    broker.SignalStateChanged();
-}
-
 StubApplet::StubApplet() = default;

 StubApplet::~StubApplet() = default;
@@ -120,5 +67,4 @@ void StubApplet::Execute() {
    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
    broker.SignalStateChanged();
 }
-
 } // namespace Service::AM::Applets
@@ -0,0 +1,24 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/am/applets/applets.h"
+
+namespace Service::AM::Applets {
+
+class StubApplet final : public Applet {
+public:
+    StubApplet();
+    ~StubApplet() override;
+
+    void Initialize() override;
+
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+};
+
+} // namespace Service::AM::Applets
@@ -95,7 +95,7 @@ static FileSys::VirtualFile GetManualRomFS() {
    return nullptr;
 }

-WebBrowser::WebBrowser(Core::Frontend::WebBrowserApplet& frontend) : frontend(frontend) {}
+WebBrowser::WebBrowser() = default;

 WebBrowser::~WebBrowser() = default;

@@ -152,6 +152,8 @@ void WebBrowser::Execute() {
        return;
    }

+    auto& frontend{Core::System::GetInstance().GetWebBrowser()};
+
    frontend.OpenPage(filename, [this] { UnpackRomFS(); }, [this] { Finalize(); });
 }

@@ -12,7 +12,7 @@ namespace Service::AM::Applets {

 class WebBrowser final : public Applet {
 public:
-    WebBrowser(Core::Frontend::WebBrowserApplet& frontend);
+    WebBrowser();
    ~WebBrowser() override;

    void Initialize() override;
@@ -32,8 +32,6 @@ public:
    void Finalize();

 private:
-    Core::Frontend::WebBrowserApplet& frontend;
-
    bool complete = false;
    bool unpacked = false;
    ResultCode status = RESULT_SUCCESS;
@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/audio/audctl.h"

 namespace Service::Audio {
@@ -13,8 +11,8 @@ AudCtl::AudCtl() : ServiceFramework{"audctl"} {
    static const FunctionInfo functions[] = {
        {0, nullptr, "GetTargetVolume"},
        {1, nullptr, "SetTargetVolume"},
-        {2, &AudCtl::GetTargetVolumeMin, "GetTargetVolumeMin"},
-        {3, &AudCtl::GetTargetVolumeMax, "GetTargetVolumeMax"},
+        {2, nullptr, "GetTargetVolumeMin"},
+        {3, nullptr, "GetTargetVolumeMax"},
        {4, nullptr, "IsTargetMute"},
        {5, nullptr, "SetTargetMute"},
        {6, nullptr, "IsTargetConnected"},
@@ -46,28 +44,4 @@ AudCtl::AudCtl() : ServiceFramework{"audctl"} {

 AudCtl::~AudCtl() = default;

-void AudCtl::GetTargetVolumeMin(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Audio, "called.");
-
-    // This service function is currently hardcoded on the
-    // actual console to this value (as of 6.0.0).
-    constexpr s32 target_min_volume = 0;
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(target_min_volume);
-}
-
-void AudCtl::GetTargetVolumeMax(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Audio, "called.");
-
-    // This service function is currently hardcoded on the
-    // actual console to this value (as of 6.0.0).
-    constexpr s32 target_max_volume = 15;
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(target_max_volume);
-}
-
 } // namespace Service::Audio
@@ -12,10 +12,6 @@ class AudCtl final : public ServiceFramework<AudCtl> {
 public:
    explicit AudCtl();
    ~AudCtl() override;
-
-private:
-    void GetTargetVolumeMin(Kernel::HLERequestContext& ctx);
-    void GetTargetVolumeMax(Kernel::HLERequestContext& ctx);
 };

 } // namespace Service::Audio
@@ -21,6 +21,8 @@
 #include "core/memory.h"
 #include "core/settings.h"

+#pragma optimize("", off)
+
 namespace Loader {
 namespace {
 struct MODHeader {
@@ -72,6 +72,15 @@ u8* GetPointer(VAddr vaddr);

 std::string ReadCString(VAddr vaddr, std::size_t max_length);

+enum class FlushMode {
+    /// Write back modified surfaces to RAM
+    Flush,
+    /// Remove region from the cache
+    Invalidate,
+    /// Write back modified surfaces to RAM, and also remove them from the cache
+    FlushAndInvalidate,
+};
+
 /**
 * Mark each page touching the region as cached.
 */
@@ -90,7 +90,6 @@ void LogSettings() {
    LogSetting("Renderer_UseResolutionFactor", Settings::values.resolution_factor);
    LogSetting("Renderer_UseFrameLimit", Settings::values.use_frame_limit);
    LogSetting("Renderer_FrameLimit", Settings::values.frame_limit);
-    LogSetting("Renderer_UseCompatibilityProfile", Settings::values.use_compatibility_profile);
    LogSetting("Renderer_UseDiskShaderCache", Settings::values.use_disk_shader_cache);
    LogSetting("Renderer_UseAccurateGpuEmulation", Settings::values.use_accurate_gpu_emulation);
    LogSetting("Renderer_UseAsynchronousGpuEmulation",
@@ -390,7 +390,6 @@ struct Values {
    float resolution_factor;
    bool use_frame_limit;
    u16 frame_limit;
-    bool use_compatibility_profile;
    bool use_disk_shader_cache;
    bool use_accurate_gpu_emulation;
    bool use_asynchronous_gpu_emulation;
@@ -3,6 +3,8 @@ add_library(video_core STATIC
    dma_pusher.h
    debug_utils/debug_utils.cpp
    debug_utils/debug_utils.h
+    engines/engine_upload.cpp
+    engines/engine_upload.h
    engines/fermi_2d.cpp
    engines/fermi_2d.h
    engines/kepler_compute.cpp
@@ -36,8 +38,6 @@ add_library(video_core STATIC
    renderer_base.h
    renderer_opengl/gl_buffer_cache.cpp
    renderer_opengl/gl_buffer_cache.h
-    renderer_opengl/gl_device.cpp
-    renderer_opengl/gl_device.h
    renderer_opengl/gl_global_cache.cpp
    renderer_opengl/gl_global_cache.h
    renderer_opengl/gl_primitive_assembler.cpp
@@ -105,8 +105,6 @@ bool DmaPusher::Step() {
                dma_state.non_incrementing = false;
                dma_increment_once = true;
                break;
-            default:
-                break;
            }
        }
    }
@@ -0,0 +1,48 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "video_core/engines/engine_upload.h"
+#include "video_core/memory_manager.h"
+#include "video_core/textures/decoders.h"
+
+namespace Tegra::Engines::Upload {
+
+State::State(MemoryManager& memory_manager, Registers& regs)
+    : memory_manager(memory_manager), regs(regs) {}
+
+void State::ProcessExec(const bool is_linear) {
+    write_offset = 0;
+    copy_size = regs.line_length_in * regs.line_count;
+    inner_buffer.resize(copy_size);
+    this->is_linear = is_linear;
+}
+
+void State::ProcessData(const u32 data, const bool is_last_call) {
+    const u32 sub_copy_size = std::min(4U, copy_size - write_offset);
+    std::memcpy(&inner_buffer[write_offset], &data, sub_copy_size);
+    write_offset += sub_copy_size;
+    if (!is_last_call) {
+        return;
+    }
+    const GPUVAddr address{regs.dest.Address()};
+    if (is_linear) {
+        memory_manager.WriteBlock(address, inner_buffer.data(), copy_size);
+    } else {
+        UNIMPLEMENTED_IF(regs.dest.z != 0);
+        UNIMPLEMENTED_IF(regs.dest.depth != 1);
+        UNIMPLEMENTED_IF(regs.dest.BlockWidth() != 1);
+        UNIMPLEMENTED_IF(regs.dest.BlockDepth() != 1);
+        const std::size_t dst_size = Tegra::Texture::CalculateSize(
+            true, 1, regs.dest.width, regs.dest.height, 1, regs.dest.BlockHeight(), 1);
+        tmp_buffer.resize(dst_size);
+        memory_manager.ReadBlock(address, tmp_buffer.data(), dst_size);
+        Tegra::Texture::SwizzleKepler(regs.dest.width, regs.dest.height, regs.dest.x, regs.dest.y,
+                                      regs.dest.BlockHeight(), copy_size, inner_buffer.data(),
+                                      tmp_buffer.data());
+        memory_manager.WriteBlock(address, tmp_buffer.data(), dst_size);
+    }
+}
+
+} // namespace Tegra::Engines::Upload
@@ -0,0 +1,75 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <cstddef>
+#include <vector>
+#include "common/bit_field.h"
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+
+namespace Tegra {
+class MemoryManager;
+}
+
+namespace Tegra::Engines::Upload {
+
+struct Registers {
+    u32 line_length_in;
+    u32 line_count;
+
+    struct {
+        u32 address_high;
+        u32 address_low;
+        u32 pitch;
+        union {
+            BitField<0, 4, u32> block_width;
+            BitField<4, 4, u32> block_height;
+            BitField<8, 4, u32> block_depth;
+        };
+        u32 width;
+        u32 height;
+        u32 depth;
+        u32 z;
+        u32 x;
+        u32 y;
+
+        GPUVAddr Address() const {
+            return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | address_low);
+        }
+
+        u32 BlockWidth() const {
+            return 1U << block_width.Value();
+        }
+
+        u32 BlockHeight() const {
+            return 1U << block_height.Value();
+        }
+
+        u32 BlockDepth() const {
+            return 1U << block_depth.Value();
+        }
+    } dest;
+};
+
+class State {
+public:
+    State(MemoryManager& memory_manager, Registers& regs);
+    ~State() = default;
+
+    void ProcessExec(const bool is_linear);
+    void ProcessData(const u32 data, const bool is_last_call);
+
+private:
+    u32 write_offset = 0;
+    u32 copy_size = 0;
+    std::vector<u8> inner_buffer;
+    std::vector<u8> tmp_buffer;
+    bool is_linear = false;
+    Registers& regs;
+    MemoryManager& memory_manager;
+};
+
+} // namespace Tegra::Engines::Upload
@@ -21,6 +21,12 @@ class RasterizerInterface;

 namespace Tegra::Engines {

+/**
+ * This Engine is known as G80_2D. Documentation can be found in:
+ * https://github.com/envytools/envytools/blob/master/rnndb/graph/g80_2d.xml
+ * https://cgit.freedesktop.org/mesa/mesa/tree/src/gallium/drivers/nouveau/nv50/nv50_2d.xml.h
+ */
+
 #define FERMI2D_REG_INDEX(field_name)                                                              \
    (offsetof(Tegra::Engines::Fermi2D::Regs, field_name) / sizeof(u32))

@@ -4,12 +4,21 @@

 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "video_core/engines/kepler_compute.h"
+#include "video_core/engines/maxwell_3d.h"
 #include "video_core/memory_manager.h"
+#include "video_core/rasterizer_interface.h"
+#include "video_core/renderer_base.h"
+#include "video_core/textures/decoders.h"

 namespace Tegra::Engines {

-KeplerCompute::KeplerCompute(MemoryManager& memory_manager) : memory_manager{memory_manager} {}
+KeplerCompute::KeplerCompute(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
+                             MemoryManager& memory_manager)
+    : system{system}, rasterizer{rasterizer}, memory_manager{memory_manager}, upload_state{
+                                                                                  memory_manager,
+                                                                                  regs.upload} {}

 KeplerCompute::~KeplerCompute() = default;

@@ -20,14 +29,34 @@ void KeplerCompute::CallMethod(const GPU::MethodCall& method_call) {
    regs.reg_array[method_call.method] = method_call.argument;

    switch (method_call.method) {
+    case KEPLER_COMPUTE_REG_INDEX(exec_upload): {
+        upload_state.ProcessExec(regs.exec_upload.linear != 0);
+        break;
+    }
+    case KEPLER_COMPUTE_REG_INDEX(data_upload): {
+        const bool is_last_call = method_call.IsLastCall();
+        upload_state.ProcessData(method_call.argument, is_last_call);
+        if (is_last_call) {
+            system.GPU().Maxwell3D().dirty_flags.OnMemoryWrite();
+        }
+        break;
+    }
    case KEPLER_COMPUTE_REG_INDEX(launch):
-        // Abort execution since compute shaders can be used to alter game memory (e.g. CUDA
-        // kernels)
-        UNREACHABLE_MSG("Compute shaders are not implemented");
+        ProcessLaunch();
        break;
    default:
        break;
    }
 }

+void KeplerCompute::ProcessLaunch() {
+
+    const GPUVAddr launch_desc_loc = regs.launch_desc_loc.Address();
+    memory_manager.ReadBlockUnsafe(launch_desc_loc, &launch_description,
+                                   LaunchParams::NUM_LAUNCH_PARAMETERS * sizeof(u32));
+
+    const GPUVAddr code_loc = regs.code_loc.Address() + launch_description.program_start;
+    LOG_WARNING(HW_GPU, "Compute Kernel Execute at Address 0x{:016x}, STUBBED", code_loc);
+}
+
 } // namespace Tegra::Engines
@@ -6,22 +6,40 @@

 #include <array>
 #include <cstddef>
+#include <vector>
+#include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "video_core/engines/engine_upload.h"
 #include "video_core/gpu.h"

+namespace Core {
+class System;
+}
+
 namespace Tegra {
 class MemoryManager;
 }

+namespace VideoCore {
+class RasterizerInterface;
+}
+
 namespace Tegra::Engines {

+/**
+ * This Engine is known as GK104_Compute. Documentation can be found in:
+ * https://github.com/envytools/envytools/blob/master/rnndb/graph/gk104_compute.xml
+ * https://cgit.freedesktop.org/mesa/mesa/tree/src/gallium/drivers/nouveau/nvc0/nve4_compute.xml.h
+ */
+
 #define KEPLER_COMPUTE_REG_INDEX(field_name)                                                       \
    (offsetof(Tegra::Engines::KeplerCompute::Regs, field_name) / sizeof(u32))

 class KeplerCompute final {
 public:
-    explicit KeplerCompute(MemoryManager& memory_manager);
+    explicit KeplerCompute(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
+                           MemoryManager& memory_manager);
    ~KeplerCompute();

    static constexpr std::size_t NumConstBuffers = 8;
@@ -31,30 +49,181 @@ public:

        union {
            struct {
-                INSERT_PADDING_WORDS(0xAF);
+                INSERT_PADDING_WORDS(0x60);
+
+                Upload::Registers upload;
+
+                struct {
+                    union {
+                        BitField<0, 1, u32> linear;
+                    };
+                } exec_upload;
+
+                u32 data_upload;
+
+                INSERT_PADDING_WORDS(0x3F);
+
+                struct {
+                    u32 address;
+                    GPUVAddr Address() const {
+                        return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address) << 8));
+                    }
+                } launch_desc_loc;
+
+                INSERT_PADDING_WORDS(0x1);

                u32 launch;

-                INSERT_PADDING_WORDS(0xC48);
+                INSERT_PADDING_WORDS(0x4A7);
+
+                struct {
+                    u32 address_high;
+                    u32 address_low;
+                    u32 limit;
+                    GPUVAddr Address() const {
+                        return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
+                                                     address_low);
+                    }
+                } tsc;
+
+                INSERT_PADDING_WORDS(0x3);
+
+                struct {
+                    u32 address_high;
+                    u32 address_low;
+                    u32 limit;
+                    GPUVAddr Address() const {
+                        return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
+                                                     address_low);
+                    }
+                } tic;
+
+                INSERT_PADDING_WORDS(0x22);
+
+                struct {
+                    u32 address_high;
+                    u32 address_low;
+                    GPUVAddr Address() const {
+                        return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
+                                                     address_low);
+                    }
+                } code_loc;
+
+                INSERT_PADDING_WORDS(0x3FE);
+
+                u32 texture_const_buffer_index;
+
+                INSERT_PADDING_WORDS(0x374);
            };
            std::array<u32, NUM_REGS> reg_array;
        };
    } regs{};
+
+    struct LaunchParams {
+        static constexpr std::size_t NUM_LAUNCH_PARAMETERS = 0x40;
+
+        INSERT_PADDING_WORDS(0x8);
+
+        u32 program_start;
+
+        INSERT_PADDING_WORDS(0x2);
+
+        BitField<30, 1, u32> linked_tsc;
+
+        BitField<0, 31, u32> grid_dim_x;
+        union {
+            BitField<0, 16, u32> grid_dim_y;
+            BitField<16, 16, u32> grid_dim_z;
+        };
+
+        INSERT_PADDING_WORDS(0x3);
+
+        BitField<0, 16, u32> shared_alloc;
+
+        BitField<0, 31, u32> block_dim_x;
+        union {
+            BitField<0, 16, u32> block_dim_y;
+            BitField<16, 16, u32> block_dim_z;
+        };
+
+        union {
+            BitField<0, 8, u32> const_buffer_enable_mask;
+            BitField<29, 2, u32> cache_layout;
+        } memory_config;
+
+        INSERT_PADDING_WORDS(0x8);
+
+        struct {
+            u32 address_low;
+            union {
+                BitField<0, 8, u32> address_high;
+                BitField<15, 17, u32> size;
+            };
+            GPUVAddr Address() const {
+                return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high.Value()) << 32) |
+                                             address_low);
+            }
+        } const_buffer_config[8];
+
+        union {
+            BitField<0, 20, u32> local_pos_alloc;
+            BitField<27, 5, u32> barrier_alloc;
+        };
+
+        union {
+            BitField<0, 20, u32> local_neg_alloc;
+            BitField<24, 5, u32> gpr_alloc;
+        };
+
+        INSERT_PADDING_WORDS(0x11);
+    } launch_description;
+
+    struct {
+        u32 write_offset = 0;
+        u32 copy_size = 0;
+        std::vector<u8> inner_buffer;
+    } state{};
+
    static_assert(sizeof(Regs) == Regs::NUM_REGS * sizeof(u32),
                  "KeplerCompute Regs has wrong size");

+    static_assert(sizeof(LaunchParams) == LaunchParams::NUM_LAUNCH_PARAMETERS * sizeof(u32),
+                  "KeplerCompute LaunchParams has wrong size");
+
    /// Write the value to the register identified by method.
    void CallMethod(const GPU::MethodCall& method_call);

 private:
+    Core::System& system;
+    VideoCore::RasterizerInterface& rasterizer;
    MemoryManager& memory_manager;
+    Upload::State upload_state;
+
+    void ProcessLaunch();
 };

 #define ASSERT_REG_POSITION(field_name, position)                                                  \
    static_assert(offsetof(KeplerCompute::Regs, field_name) == position * 4,                       \
                  "Field " #field_name " has invalid position")

+#define ASSERT_LAUNCH_PARAM_POSITION(field_name, position)                                         \
+    static_assert(offsetof(KeplerCompute::LaunchParams, field_name) == position * 4,               \
+                  "Field " #field_name " has invalid position")
+
+ASSERT_REG_POSITION(upload, 0x60);
+ASSERT_REG_POSITION(exec_upload, 0x6C);
+ASSERT_REG_POSITION(data_upload, 0x6D);
 ASSERT_REG_POSITION(launch, 0xAF);
+ASSERT_REG_POSITION(tsc, 0x557);
+ASSERT_REG_POSITION(tic, 0x55D);
+ASSERT_REG_POSITION(code_loc, 0x582);
+ASSERT_REG_POSITION(texture_const_buffer_index, 0x982);
+ASSERT_LAUNCH_PARAM_POSITION(program_start, 0x8);
+ASSERT_LAUNCH_PARAM_POSITION(grid_dim_x, 0xC);
+ASSERT_LAUNCH_PARAM_POSITION(shared_alloc, 0x11);
+ASSERT_LAUNCH_PARAM_POSITION(block_dim_x, 0x12);
+ASSERT_LAUNCH_PARAM_POSITION(memory_config, 0x14);
+ASSERT_LAUNCH_PARAM_POSITION(const_buffer_config, 0x1D);

 #undef ASSERT_REG_POSITION

@@ -14,9 +14,8 @@

 namespace Tegra::Engines {

-KeplerMemory::KeplerMemory(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
-                           MemoryManager& memory_manager)
-    : system{system}, rasterizer{rasterizer}, memory_manager{memory_manager} {}
+KeplerMemory::KeplerMemory(Core::System& system, MemoryManager& memory_manager)
+    : system{system}, memory_manager{memory_manager}, upload_state{memory_manager, regs.upload} {}

 KeplerMemory::~KeplerMemory() = default;

@@ -28,46 +27,18 @@ void KeplerMemory::CallMethod(const GPU::MethodCall& method_call) {

    switch (method_call.method) {
    case KEPLERMEMORY_REG_INDEX(exec): {
-        ProcessExec();
+        upload_state.ProcessExec(regs.exec.linear != 0);
        break;
    }
    case KEPLERMEMORY_REG_INDEX(data): {
-        ProcessData(method_call.argument, method_call.IsLastCall());
+        const bool is_last_call = method_call.IsLastCall();
+        upload_state.ProcessData(method_call.argument, is_last_call);
+        if (is_last_call) {
+            system.GPU().Maxwell3D().dirty_flags.OnMemoryWrite();
+        }
        break;
    }
    }
 }

-void KeplerMemory::ProcessExec() {
-    state.write_offset = 0;
-    state.copy_size = regs.line_length_in * regs.line_count;
-    state.inner_buffer.resize(state.copy_size);
-}
-
-void KeplerMemory::ProcessData(u32 data, bool is_last_call) {
-    const u32 sub_copy_size = std::min(4U, state.copy_size - state.write_offset);
-    std::memcpy(&state.inner_buffer[state.write_offset], &regs.data, sub_copy_size);
-    state.write_offset += sub_copy_size;
-    if (is_last_call) {
-        const GPUVAddr address{regs.dest.Address()};
-        if (regs.exec.linear != 0) {
-            memory_manager.WriteBlock(address, state.inner_buffer.data(), state.copy_size);
-        } else {
-            UNIMPLEMENTED_IF(regs.dest.z != 0);
-            UNIMPLEMENTED_IF(regs.dest.depth != 1);
-            UNIMPLEMENTED_IF(regs.dest.BlockWidth() != 1);
-            UNIMPLEMENTED_IF(regs.dest.BlockDepth() != 1);
-            const std::size_t dst_size = Tegra::Texture::CalculateSize(
-                true, 1, regs.dest.width, regs.dest.height, 1, regs.dest.BlockHeight(), 1);
-            std::vector<u8> tmp_buffer(dst_size);
-            memory_manager.ReadBlock(address, tmp_buffer.data(), dst_size);
-            Tegra::Texture::SwizzleKepler(regs.dest.width, regs.dest.height, regs.dest.x,
-                                          regs.dest.y, regs.dest.BlockHeight(), state.copy_size,
-                                          state.inner_buffer.data(), tmp_buffer.data());
-            memory_manager.WriteBlock(address, tmp_buffer.data(), dst_size);
-        }
-        system.GPU().Maxwell3D().dirty_flags.OnMemoryWrite();
-    }
-}
-
 } // namespace Tegra::Engines
@@ -10,6 +10,7 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "video_core/engines/engine_upload.h"
 #include "video_core/gpu.h"

 namespace Core {
@@ -20,19 +21,20 @@ namespace Tegra {
 class MemoryManager;
 }

-namespace VideoCore {
-class RasterizerInterface;
-}
-
 namespace Tegra::Engines {

+/**
+ * This Engine is known as P2MF. Documentation can be found in:
+ * https://github.com/envytools/envytools/blob/master/rnndb/graph/gk104_p2mf.xml
+ * https://cgit.freedesktop.org/mesa/mesa/tree/src/gallium/drivers/nouveau/nvc0/nve4_p2mf.xml.h
+ */
+
 #define KEPLERMEMORY_REG_INDEX(field_name)                                                         \
    (offsetof(Tegra::Engines::KeplerMemory::Regs, field_name) / sizeof(u32))

 class KeplerMemory final {
 public:
-    KeplerMemory(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
-                 MemoryManager& memory_manager);
+    KeplerMemory(Core::System& system, MemoryManager& memory_manager);
    ~KeplerMemory();

    /// Write the value to the register identified by method.
@@ -45,42 +47,7 @@ public:
            struct {
                INSERT_PADDING_WORDS(0x60);

-                u32 line_length_in;
-                u32 line_count;
-
-                struct {
-                    u32 address_high;
-                    u32 address_low;
-                    u32 pitch;
-                    union {
-                        BitField<0, 4, u32> block_width;
-                        BitField<4, 4, u32> block_height;
-                        BitField<8, 4, u32> block_depth;
-                    };
-                    u32 width;
-                    u32 height;
-                    u32 depth;
-                    u32 z;
-                    u32 x;
-                    u32 y;
-
-                    GPUVAddr Address() const {
-                        return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
-                                                     address_low);
-                    }
-
-                    u32 BlockWidth() const {
-                        return 1U << block_width.Value();
-                    }
-
-                    u32 BlockHeight() const {
-                        return 1U << block_height.Value();
-                    }
-
-                    u32 BlockDepth() const {
-                        return 1U << block_depth.Value();
-                    }
-                } dest;
+                Upload::Registers upload;

                struct {
                    union {
@@ -96,28 +63,17 @@ public:
        };
    } regs{};

-    struct {
-        u32 write_offset = 0;
-        u32 copy_size = 0;
-        std::vector<u8> inner_buffer;
-    } state{};
-
 private:
    Core::System& system;
-    VideoCore::RasterizerInterface& rasterizer;
    MemoryManager& memory_manager;
-
-    void ProcessExec();
-    void ProcessData(u32 data, bool is_last_call);
+    Upload::State upload_state;
 };

 #define ASSERT_REG_POSITION(field_name, position)                                                  \
    static_assert(offsetof(KeplerMemory::Regs, field_name) == position * 4,                        \
                  "Field " #field_name " has invalid position")

-ASSERT_REG_POSITION(line_length_in, 0x60);
-ASSERT_REG_POSITION(line_count, 0x61);
-ASSERT_REG_POSITION(dest, 0x62);
+ASSERT_REG_POSITION(upload, 0x60);
 ASSERT_REG_POSITION(exec, 0x6C);
 ASSERT_REG_POSITION(data, 0x6D);
 #undef ASSERT_REG_POSITION
@@ -20,8 +20,8 @@ constexpr u32 MacroRegistersStart = 0xE00;

 Maxwell3D::Maxwell3D(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
                     MemoryManager& memory_manager)
-    : system{system}, rasterizer{rasterizer}, memory_manager{memory_manager}, macro_interpreter{
-                                                                                  *this} {
+    : system{system}, rasterizer{rasterizer}, memory_manager{memory_manager},
+      macro_interpreter{*this}, upload_state{memory_manager, regs.upload} {
    InitializeRegisterDefaults();
 }

@@ -253,6 +253,18 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
        ProcessSyncPoint();
        break;
    }
+    case MAXWELL3D_REG_INDEX(exec_upload): {
+        upload_state.ProcessExec(regs.exec_upload.linear != 0);
+        break;
+    }
+    case MAXWELL3D_REG_INDEX(data_upload): {
+        const bool is_last_call = method_call.IsLastCall();
+        upload_state.ProcessData(method_call.argument, is_last_call);
+        if (is_last_call) {
+            dirty_flags.OnMemoryWrite();
+        }
+        break;
+    }
    default:
        break;
    }
@@ -14,6 +14,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/math_util.h"
+#include "video_core/engines/engine_upload.h"
 #include "video_core/gpu.h"
 #include "video_core/macro_interpreter.h"
 #include "video_core/textures/texture.h"
@@ -32,6 +33,12 @@ class RasterizerInterface;

 namespace Tegra::Engines {

+/**
+ * This Engine is known as GF100_3D. Documentation can be found in:
+ * https://github.com/envytools/envytools/blob/master/rnndb/graph/gf100_3d.xml
+ * https://cgit.freedesktop.org/mesa/mesa/tree/src/gallium/drivers/nouveau/nvc0/nvc0_3d.xml.h
+ */
+
 #define MAXWELL3D_REG_INDEX(field_name)                                                            \
    (offsetof(Tegra::Engines::Maxwell3D::Regs, field_name) / sizeof(u32))

@@ -243,10 +250,9 @@ public:
                    return "10_10_10_2";
                case Size::Size_11_11_10:
                    return "11_11_10";
-                default:
-                    UNREACHABLE();
-                    return {};
                }
+                UNREACHABLE();
+                return {};
            }

            std::string TypeString() const {
@@ -580,7 +586,18 @@ public:
                    u32 bind;
                } macros;

-                INSERT_PADDING_WORDS(0x69);
+                INSERT_PADDING_WORDS(0x17);
+
+                Upload::Registers upload;
+                struct {
+                    union {
+                        BitField<0, 1, u32> linear;
+                    };
+                } exec_upload;
+
+                u32 data_upload;
+
+                INSERT_PADDING_WORDS(0x44);

                struct {
                    union {
@@ -1176,6 +1193,8 @@ private:
    /// Interpreter for the macro codes uploaded to the GPU.
    MacroInterpreter macro_interpreter;

+    Upload::State upload_state;
+
    /// Retrieves information about a specific TIC entry from the TIC buffer.
    Texture::TICEntry GetTICEntry(u32 tic_index) const;

@@ -1219,6 +1238,9 @@ private:
                  "Field " #field_name " has invalid position")

 ASSERT_REG_POSITION(macros, 0x45);
+ASSERT_REG_POSITION(upload, 0x60);
+ASSERT_REG_POSITION(exec_upload, 0x6C);
+ASSERT_REG_POSITION(data_upload, 0x6D);
 ASSERT_REG_POSITION(sync_info, 0xB2);
 ASSERT_REG_POSITION(tfb_enabled, 0x1D1);
 ASSERT_REG_POSITION(rt, 0x200);
@@ -83,57 +83,66 @@ void MaxwellDMA::HandleCopy() {

    ASSERT(regs.exec.enable_2d == 1);

-    const std::size_t copy_size = regs.x_count * regs.y_count;
-
-    auto source_ptr{memory_manager.GetPointer(source)};
-    auto dst_ptr{memory_manager.GetPointer(dest)};
-
-    if (!source_ptr) {
-        LOG_ERROR(HW_GPU, "source_ptr is invalid");
-        return;
-    }
-
-    if (!dst_ptr) {
-        LOG_ERROR(HW_GPU, "dst_ptr is invalid");
-        return;
-    }
-
-    const auto FlushAndInvalidate = [&](u32 src_size, u64 dst_size) {
-        // TODO(Subv): For now, manually flush the regions until we implement GPU-accelerated
-        // copying.
-        rasterizer.FlushRegion(ToCacheAddr(source_ptr), src_size);
-
-        // We have to invalidate the destination region to evict any outdated surfaces from the
-        // cache. We do this before actually writing the new data because the destination address
-        // might contain a dirty surface that will have to be written back to memory.
-        rasterizer.InvalidateRegion(ToCacheAddr(dst_ptr), dst_size);
-    };
-
    if (regs.exec.is_dst_linear && !regs.exec.is_src_linear) {
        ASSERT(regs.src_params.size_z == 1);
        // If the input is tiled and the output is linear, deswizzle the input and copy it over.
-
        const u32 src_bytes_per_pixel = regs.src_pitch / regs.src_params.size_x;
+        const std::size_t src_size = Texture::CalculateSize(
+            true, src_bytes_per_pixel, regs.src_params.size_x, regs.src_params.size_y,
+            regs.src_params.size_z, regs.src_params.BlockHeight(), regs.src_params.BlockDepth());

-        FlushAndInvalidate(regs.src_pitch * regs.src_params.size_y,
-                           copy_size * src_bytes_per_pixel);
+        const std::size_t dst_size = regs.dst_pitch * regs.y_count;
+
+        if (read_buffer.size() < src_size) {
+            read_buffer.resize(src_size);
+        }
+
+        if (write_buffer.size() < dst_size) {
+            write_buffer.resize(dst_size);
+        }
+
+        memory_manager.ReadBlock(source, read_buffer.data(), src_size);
+        memory_manager.ReadBlock(dest, write_buffer.data(), dst_size);

        Texture::UnswizzleSubrect(regs.x_count, regs.y_count, regs.dst_pitch,
-                                  regs.src_params.size_x, src_bytes_per_pixel, source_ptr, dst_ptr,
-                                  regs.src_params.BlockHeight(), regs.src_params.pos_x,
-                                  regs.src_params.pos_y);
+                                  regs.src_params.size_x, src_bytes_per_pixel, read_buffer.data(),
+                                  write_buffer.data(), regs.src_params.BlockHeight(),
+                                  regs.src_params.pos_x, regs.src_params.pos_y);
+
+        memory_manager.WriteBlock(dest, write_buffer.data(), dst_size);
    } else {
-        ASSERT(regs.dst_params.size_z == 1);
-        ASSERT(regs.src_pitch == regs.x_count);
+        ASSERT(regs.dst_params.BlockDepth() == 1);

-        const u32 src_bpp = regs.src_pitch / regs.x_count;
+        const u32 src_bytes_per_pixel = regs.src_pitch / regs.x_count;

-        FlushAndInvalidate(regs.src_pitch * regs.y_count,
-                           regs.dst_params.size_x * regs.dst_params.size_y * src_bpp);
+        const std::size_t dst_size = Texture::CalculateSize(
+            true, src_bytes_per_pixel, regs.dst_params.size_x, regs.dst_params.size_y,
+            regs.dst_params.size_z, regs.dst_params.BlockHeight(), regs.dst_params.BlockDepth());
+
+        const std::size_t dst_layer_size = Texture::CalculateSize(
+            true, src_bytes_per_pixel, regs.dst_params.size_x, regs.dst_params.size_y, 1,
+            regs.dst_params.BlockHeight(), regs.dst_params.BlockDepth());
+
+        const std::size_t src_size = regs.src_pitch * regs.y_count;
+
+        if (read_buffer.size() < src_size) {
+            read_buffer.resize(src_size);
+        }
+
+        if (write_buffer.size() < dst_size) {
+            write_buffer.resize(dst_size);
+        }
+
+        memory_manager.ReadBlock(source, read_buffer.data(), src_size);
+        memory_manager.ReadBlock(dest, write_buffer.data(), dst_size);

        // If the input is linear and the output is tiled, swizzle the input and copy it over.
        Texture::SwizzleSubrect(regs.x_count, regs.y_count, regs.src_pitch, regs.dst_params.size_x,
-                                src_bpp, dst_ptr, source_ptr, regs.dst_params.BlockHeight());
+                                src_bytes_per_pixel,
+                                write_buffer.data() + dst_layer_size * regs.dst_params.pos_z,
+                                read_buffer.data(), regs.dst_params.BlockHeight());
+
+        memory_manager.WriteBlock(dest, write_buffer.data(), dst_size);
    }
 }

@@ -6,6 +6,7 @@

 #include <array>
 #include <cstddef>
+#include <vector>
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -25,6 +26,11 @@ class RasterizerInterface;

 namespace Tegra::Engines {

+/**
+ * This Engine is known as GK104_Copy. Documentation can be found in:
+ * https://github.com/envytools/envytools/blob/master/rnndb/fifo/gk104_copy.xml
+ */
+
 class MaxwellDMA final {
 public:
    explicit MaxwellDMA(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
@@ -63,6 +69,16 @@ public:

        static_assert(sizeof(Parameters) == 24, "Parameters has wrong size");

+        enum class ComponentMode : u32 {
+            Src0 = 0,
+            Src1 = 1,
+            Src2 = 2,
+            Src3 = 3,
+            Const0 = 4,
+            Const1 = 5,
+            Zero = 6,
+        };
+
        enum class CopyMode : u32 {
            None = 0,
            Unk1 = 1,
@@ -128,7 +144,26 @@ public:
                u32 x_count;
                u32 y_count;

-                INSERT_PADDING_WORDS(0xBB);
+                INSERT_PADDING_WORDS(0xB8);
+
+                u32 const0;
+                u32 const1;
+                union {
+                    BitField<0, 4, ComponentMode> component0;
+                    BitField<4, 4, ComponentMode> component1;
+                    BitField<8, 4, ComponentMode> component2;
+                    BitField<12, 4, ComponentMode> component3;
+                    BitField<16, 2, u32> component_size;
+                    BitField<20, 3, u32> src_num_components;
+                    BitField<24, 3, u32> dst_num_components;
+
+                    u32 SrcBytePerPixel() const {
+                        return src_num_components.Value() * component_size.Value();
+                    }
+                    u32 DstBytePerPixel() const {
+                        return dst_num_components.Value() * component_size.Value();
+                    }
+                } swizzle_config;

                Parameters dst_params;

@@ -149,6 +184,9 @@ private:

    MemoryManager& memory_manager;

+    std::vector<u8> read_buffer;
+    std::vector<u8> write_buffer;
+
    /// Performs the copy from the source buffer to the destination buffer as configured in the
    /// registers.
    void HandleCopy();
@@ -165,6 +203,9 @@ ASSERT_REG_POSITION(src_pitch, 0x104);
 ASSERT_REG_POSITION(dst_pitch, 0x105);
 ASSERT_REG_POSITION(x_count, 0x106);
 ASSERT_REG_POSITION(y_count, 0x107);
+ASSERT_REG_POSITION(const0, 0x1C0);
+ASSERT_REG_POSITION(const1, 0x1C1);
+ASSERT_REG_POSITION(swizzle_config, 0x1C2);
 ASSERT_REG_POSITION(dst_params, 0x1C3);
 ASSERT_REG_POSITION(src_params, 0x1CA);

@@ -35,9 +35,9 @@ GPU::GPU(Core::System& system, VideoCore::RendererBase& renderer) : renderer{ren
    dma_pusher = std::make_unique<Tegra::DmaPusher>(*this);
    maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, rasterizer, *memory_manager);
    fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer, *memory_manager);
-    kepler_compute = std::make_unique<Engines::KeplerCompute>(*memory_manager);
+    kepler_compute = std::make_unique<Engines::KeplerCompute>(system, rasterizer, *memory_manager);
    maxwell_dma = std::make_unique<Engines::MaxwellDMA>(system, rasterizer, *memory_manager);
-    kepler_memory = std::make_unique<Engines::KeplerMemory>(system, rasterizer, *memory_manager);
+    kepler_memory = std::make_unique<Engines::KeplerMemory>(system, *memory_manager);
 }

 GPU::~GPU() = default;
@@ -1,45 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstddef>
-#include <glad/glad.h>
-
-#include "common/logging/log.h"
-#include "video_core/renderer_opengl/gl_device.h"
-
-namespace OpenGL {
-
-namespace {
-template <typename T>
-T GetInteger(GLenum pname) {
-    GLint temporary;
-    glGetIntegerv(pname, &temporary);
-    return static_cast<T>(temporary);
-}
-} // Anonymous namespace
-
-Device::Device() {
-    uniform_buffer_alignment = GetInteger<std::size_t>(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT);
-    has_variable_aoffi = TestVariableAoffi();
-}
-
-bool Device::TestVariableAoffi() {
-    const GLchar* AOFFI_TEST = R"(#version 430 core
-uniform sampler2D tex;
-uniform ivec2 variable_offset;
-void main() {
-    gl_Position = textureOffset(tex, vec2(0), variable_offset);
-}
-)";
-    const GLuint shader{glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &AOFFI_TEST)};
-    GLint link_status{};
-    glGetProgramiv(shader, GL_LINK_STATUS, &link_status);
-    glDeleteProgram(shader);
-
-    const bool supported{link_status == GL_TRUE};
-    LOG_INFO(Render_OpenGL, "Renderer_VariableAOFFI: {}", supported);
-    return supported;
-}
-
-} // namespace OpenGL
@@ -1,30 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-
-namespace OpenGL {
-
-class Device {
-public:
-    Device();
-
-    std::size_t GetUniformBufferAlignment() const {
-        return uniform_buffer_alignment;
-    }
-
-    bool HasVariableAoffi() const {
-        return has_variable_aoffi;
-    }
-
-private:
-    static bool TestVariableAoffi();
-
-    std::size_t uniform_buffer_alignment{};
-    bool has_variable_aoffi{};
-};
-
-} // namespace OpenGL
@@ -99,7 +99,7 @@ struct FramebufferCacheKey {
 };

 RasterizerOpenGL::RasterizerOpenGL(Core::System& system, ScreenInfo& info)
-    : res_cache{*this}, shader_cache{*this, system, device}, global_cache{*this}, system{system},
+    : res_cache{*this}, shader_cache{*this, system}, global_cache{*this}, system{system},
      screen_info{info}, buffer_cache(*this, STREAM_BUFFER_SIZE) {
    OpenGLState::ApplyDefaultState();

@@ -107,6 +107,8 @@ RasterizerOpenGL::RasterizerOpenGL(Core::System& system, ScreenInfo& info)
    state.draw.shader_program = 0;
    state.Apply();

+    glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uniform_buffer_alignment);
+
    LOG_DEBUG(Render_OpenGL, "Sync fixed function OpenGL state here");
    CheckExtensions();
 }
@@ -305,8 +307,6 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
            case Maxwell::ShaderProgram::Geometry:
                shader_program_manager->UseTrivialGeometryShader();
                break;
-            default:
-                break;
            }
            continue;
        }
@@ -315,8 +315,8 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {

        GLShader::MaxwellUniformData ubo{};
        ubo.SetFromRegs(gpu, stage);
-        const GLintptr offset =
-            buffer_cache.UploadHostMemory(&ubo, sizeof(ubo), device.GetUniformBufferAlignment());
+        const GLintptr offset = buffer_cache.UploadHostMemory(
+            &ubo, sizeof(ubo), static_cast<std::size_t>(uniform_buffer_alignment));

        // Bind the emulation info buffer
        bind_ubo_pushbuffer.Push(buffer_cache.GetHandle(), offset,
@@ -700,24 +700,23 @@ void RasterizerOpenGL::DrawArrays() {
    // Add space for index buffer (keeping in mind non-core primitives)
    switch (regs.draw.topology) {
    case Maxwell::PrimitiveTopology::Quads:
-        buffer_size = Common::AlignUp(buffer_size, 4) +
+        buffer_size = Common::AlignUp<std::size_t>(buffer_size, 4) +
                      primitive_assembler.CalculateQuadSize(regs.vertex_buffer.count);
        break;
    default:
        if (is_indexed) {
-            buffer_size = Common::AlignUp(buffer_size, 4) + CalculateIndexBufferSize();
+            buffer_size = Common::AlignUp<std::size_t>(buffer_size, 4) + CalculateIndexBufferSize();
        }
        break;
    }

    // Uniform space for the 5 shader stages
-    buffer_size = Common::AlignUp<std::size_t>(buffer_size, 4) +
-                  (sizeof(GLShader::MaxwellUniformData) + device.GetUniformBufferAlignment()) *
-                      Maxwell::MaxShaderStage;
+    buffer_size =
+        Common::AlignUp<std::size_t>(buffer_size, 4) +
+        (sizeof(GLShader::MaxwellUniformData) + uniform_buffer_alignment) * Maxwell::MaxShaderStage;

    // Add space for at least 18 constant buffers
-    buffer_size +=
-        Maxwell::MaxConstBuffers * (MaxConstbufferSize + device.GetUniformBufferAlignment());
+    buffer_size += Maxwell::MaxConstBuffers * (MaxConstbufferSize + uniform_buffer_alignment);

    const bool invalidate = buffer_cache.Map(buffer_size);
    if (invalidate) {
@@ -849,8 +848,8 @@ void RasterizerOpenGL::SetupConstBuffers(Tegra::Engines::Maxwell3D::Regs::Shader
        size = Common::AlignUp(size, sizeof(GLvec4));
        ASSERT_MSG(size <= MaxConstbufferSize, "Constbuffer too big");

-        const GLintptr const_buffer_offset =
-            buffer_cache.UploadMemory(buffer.address, size, device.GetUniformBufferAlignment());
+        const GLintptr const_buffer_offset = buffer_cache.UploadMemory(
+            buffer.address, size, static_cast<std::size_t>(uniform_buffer_alignment));

        bind_ubo_pushbuffer.Push(buffer_cache.GetHandle(), const_buffer_offset, size);
    }
@@ -21,7 +21,6 @@
 #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_device.h"
 #include "video_core/renderer_opengl/gl_global_cache.h"
 #include "video_core/renderer_opengl/gl_primitive_assembler.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
@@ -173,7 +172,6 @@ private:
    /// but are needed for correct emulation
    void CheckExtensions();

-    const Device device;
    OpenGLState state;

    RasterizerCacheOpenGL res_cache;
@@ -182,6 +180,7 @@ private:
    SamplerCacheOpenGL sampler_cache;

    Core::System& system;
+
    ScreenInfo& screen_info;

    std::unique_ptr<GLShader::ProgramManager> shader_program_manager;
@@ -197,6 +196,7 @@ private:
    static constexpr std::size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
    OGLBufferCache buffer_cache;
    PrimitiveAssembler primitive_assembler{buffer_cache};
+    GLint uniform_buffer_alignment;

    BindBuffersRangePushBuffer bind_ubo_pushbuffer{GL_UNIFORM_BUFFER};
    BindBuffersRangePushBuffer bind_ssbo_pushbuffer{GL_SHADER_STORAGE_BUFFER};
@@ -136,8 +136,8 @@ u64 GetUniqueIdentifier(Maxwell::ShaderProgram program_type, const ProgramCode&
 }

 /// Creates an unspecialized program from code streams
-GLShader::ProgramResult CreateProgram(const Device& device, Maxwell::ShaderProgram program_type,
-                                      ProgramCode program_code, ProgramCode program_code_b) {
+GLShader::ProgramResult CreateProgram(Maxwell::ShaderProgram program_type, ProgramCode program_code,
+                                      ProgramCode program_code_b) {
    GLShader::ShaderSetup setup(program_code);
    if (program_type == Maxwell::ShaderProgram::VertexA) {
        // VertexB is always enabled, so when VertexA is enabled, we have two vertex shaders.
@@ -151,11 +151,11 @@ GLShader::ProgramResult CreateProgram(const Device& device, Maxwell::ShaderProgr
    switch (program_type) {
    case Maxwell::ShaderProgram::VertexA:
    case Maxwell::ShaderProgram::VertexB:
-        return GLShader::GenerateVertexShader(device, setup);
+        return GLShader::GenerateVertexShader(setup);
    case Maxwell::ShaderProgram::Geometry:
-        return GLShader::GenerateGeometryShader(device, setup);
+        return GLShader::GenerateGeometryShader(setup);
    case Maxwell::ShaderProgram::Fragment:
-        return GLShader::GenerateFragmentShader(device, setup);
+        return GLShader::GenerateFragmentShader(setup);
    default:
        LOG_CRITICAL(HW_GPU, "Unimplemented program_type={}", static_cast<u32>(program_type));
        UNREACHABLE();
@@ -214,20 +214,22 @@ std::set<GLenum> GetSupportedFormats() {
    return supported_formats;
 }

-} // Anonymous namespace
+} // namespace

-CachedShader::CachedShader(const Device& device, VAddr cpu_addr, u64 unique_identifier,
+CachedShader::CachedShader(VAddr cpu_addr, u64 unique_identifier,
                           Maxwell::ShaderProgram program_type, ShaderDiskCacheOpenGL& disk_cache,
                           const PrecompiledPrograms& precompiled_programs,
                           ProgramCode&& program_code, ProgramCode&& program_code_b, u8* host_ptr)
    : RasterizerCacheObject{host_ptr}, host_ptr{host_ptr}, cpu_addr{cpu_addr},
      unique_identifier{unique_identifier}, program_type{program_type}, disk_cache{disk_cache},
      precompiled_programs{precompiled_programs} {
-    const std::size_t code_size{CalculateProgramSize(program_code)};
-    const std::size_t code_size_b{program_code_b.empty() ? 0
-                                                         : CalculateProgramSize(program_code_b)};
-    GLShader::ProgramResult program_result{
-        CreateProgram(device, program_type, program_code, program_code_b)};
+
+    const std::size_t code_size = CalculateProgramSize(program_code);
+    const std::size_t code_size_b =
+        program_code_b.empty() ? 0 : CalculateProgramSize(program_code_b);
+
+    GLShader::ProgramResult program_result =
+        CreateProgram(program_type, program_code, program_code_b);
    if (program_result.first.empty()) {
        // TODO(Rodrigo): Unimplemented shader stages hit here, avoid using these for now
        return;
@@ -251,6 +253,7 @@ CachedShader::CachedShader(VAddr cpu_addr, u64 unique_identifier,
    : RasterizerCacheObject{host_ptr}, cpu_addr{cpu_addr}, unique_identifier{unique_identifier},
      program_type{program_type}, disk_cache{disk_cache}, precompiled_programs{
                                                              precompiled_programs} {
+
    code = std::move(result.first);
    entries = result.second;
    shader_length = entries.shader_length;
@@ -343,9 +346,8 @@ ShaderDiskCacheUsage CachedShader::GetUsage(GLenum primitive_mode,
    return {unique_identifier, base_bindings, primitive_mode};
 }

-ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer, Core::System& system,
-                                     const Device& device)
-    : RasterizerCache{rasterizer}, disk_cache{system}, device{device} {}
+ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer, Core::System& system)
+    : RasterizerCache{rasterizer}, disk_cache{system} {}

 void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
                                      const VideoCore::DiskResourceLoadCallback& callback) {
@@ -363,10 +365,6 @@ void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
    if (stop_loading)
        return;

-    // Track if precompiled cache was altered during loading to know if we have to serialize the
-    // virtual precompiled cache file back to the hard drive
-    bool precompiled_cache_altered = false;
-
    // Build shaders
    if (callback)
        callback(VideoCore::LoadCallbackStage::Build, 0, usages.size());
@@ -388,7 +386,6 @@ void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
            if (!shader) {
                // Invalidate the precompiled cache if a shader dumped shader was rejected
                disk_cache.InvalidatePrecompiled();
-                precompiled_cache_altered = true;
                dumps.clear();
            }
        }
@@ -410,13 +407,8 @@ void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
        if (dumps.find(usage) == dumps.end()) {
            const auto& program = precompiled_programs.at(usage);
            disk_cache.SaveDump(usage, program->handle);
-            precompiled_cache_altered = true;
        }
    }
-
-    if (precompiled_cache_altered) {
-        disk_cache.SaveVirtualPrecompiledFile();
-    }
 }

 CachedProgram ShaderCacheOpenGL::GeneratePrecompiledProgram(
@@ -449,18 +441,17 @@ std::unordered_map<u64, UnspecializedShader> ShaderCacheOpenGL::GenerateUnspecia
    const std::unordered_map<u64, ShaderDiskCacheDecompiled>& decompiled) {
    std::unordered_map<u64, UnspecializedShader> unspecialized;

-    if (callback) {
+    if (callback)
        callback(VideoCore::LoadCallbackStage::Decompile, 0, raws.size());
-    }

    for (std::size_t i = 0; i < raws.size(); ++i) {
-        if (stop_loading) {
+        if (stop_loading)
            return {};
-        }
+
        const auto& raw{raws[i]};
-        const u64 unique_identifier{raw.GetUniqueIdentifier()};
-        const u64 calculated_hash{
-            GetUniqueIdentifier(raw.GetProgramType(), raw.GetProgramCode(), raw.GetProgramCodeB())};
+        const u64 unique_identifier = raw.GetUniqueIdentifier();
+        const u64 calculated_hash =
+            GetUniqueIdentifier(raw.GetProgramType(), raw.GetProgramCode(), raw.GetProgramCodeB());
        if (unique_identifier != calculated_hash) {
            LOG_ERROR(
                Render_OpenGL,
@@ -477,8 +468,8 @@ std::unordered_map<u64, UnspecializedShader> ShaderCacheOpenGL::GenerateUnspecia
            result = {stored_decompiled.code, stored_decompiled.entries};
        } else {
            // Otherwise decompile the shader at boot and save the result to the decompiled file
-            result = CreateProgram(device, raw.GetProgramType(), raw.GetProgramCode(),
-                                   raw.GetProgramCodeB());
+            result =
+                CreateProgram(raw.GetProgramType(), raw.GetProgramCode(), raw.GetProgramCodeB());
            disk_cache.SaveDecompiled(unique_identifier, result.first, result.second);
        }

@@ -488,9 +479,8 @@ std::unordered_map<u64, UnspecializedShader> ShaderCacheOpenGL::GenerateUnspecia
            {raw.GetUniqueIdentifier(),
             {std::move(result.first), std::move(result.second), raw.GetProgramType()}});

-        if (callback) {
+        if (callback)
            callback(VideoCore::LoadCallbackStage::Decompile, i, raws.size());
-        }
    }
    return unspecialized;
 }
@@ -525,7 +515,7 @@ Shader ShaderCacheOpenGL::GetStageProgram(Maxwell::ShaderProgram program) {
                                               precompiled_programs, found->second, host_ptr);
        } else {
            shader = std::make_shared<CachedShader>(
-                device, cpu_addr, unique_identifier, program, disk_cache, precompiled_programs,
+                cpu_addr, unique_identifier, program, disk_cache, precompiled_programs,
                std::move(program_code), std::move(program_code_b), host_ptr);
        }
        Register(shader);
@@ -27,7 +27,6 @@ class System;
 namespace OpenGL {

 class CachedShader;
-class Device;
 class RasterizerOpenGL;
 struct UnspecializedShader;

@@ -39,7 +38,7 @@ using PrecompiledShaders = std::unordered_map<u64, GLShader::ProgramResult>;

 class CachedShader final : public RasterizerCacheObject {
 public:
-    explicit CachedShader(const Device& device, VAddr cpu_addr, u64 unique_identifier,
+    explicit CachedShader(VAddr cpu_addr, u64 unique_identifier,
                          Maxwell::ShaderProgram program_type, ShaderDiskCacheOpenGL& disk_cache,
                          const PrecompiledPrograms& precompiled_programs,
                          ProgramCode&& program_code, ProgramCode&& program_code_b, u8* host_ptr);
@@ -113,8 +112,7 @@ private:

 class ShaderCacheOpenGL final : public RasterizerCache<Shader> {
 public:
-    explicit ShaderCacheOpenGL(RasterizerOpenGL& rasterizer, Core::System& system,
-                               const Device& device);
+    explicit ShaderCacheOpenGL(RasterizerOpenGL& rasterizer, Core::System& system);

    /// Loads disk cache for the current game
    void LoadDiskCache(const std::atomic_bool& stop_loading,
@@ -132,8 +130,6 @@ private:
    CachedProgram GeneratePrecompiledProgram(const ShaderDiskCacheDump& dump,
                                             const std::set<GLenum>& supported_formats);

-    const Device& device;
-
    std::array<Shader, Maxwell::MaxShaderProgram> last_shaders;

    ShaderDiskCacheOpenGL disk_cache;
@@ -15,7 +15,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "video_core/engines/maxwell_3d.h"
-#include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_decompiler.h"
 #include "video_core/shader/shader_ir.h"
@@ -136,9 +135,8 @@ bool IsPrecise(Node node) {

 class GLSLDecompiler final {
 public:
-    explicit GLSLDecompiler(const Device& device, const ShaderIR& ir, ShaderStage stage,
-                            std::string suffix)
-        : device{device}, ir{ir}, stage{stage}, suffix{suffix}, header{ir.GetHeader()} {}
+    explicit GLSLDecompiler(const ShaderIR& ir, ShaderStage stage, std::string suffix)
+        : ir{ir}, stage{stage}, suffix{suffix}, header{ir.GetHeader()} {}

    void Decompile() {
        DeclareVertex();
@@ -804,12 +802,8 @@ private:
                // Inline the string as an immediate integer in GLSL (AOFFI arguments are required
                // to be constant by the standard).
                expr += std::to_string(static_cast<s32>(immediate->GetValue()));
-            } else if (device.HasVariableAoffi()) {
-                // Avoid using variable AOFFI on unsupported devices.
-                expr += "ftoi(" + Visit(operand) + ')';
            } else {
-                // Insert 0 on devices not supporting variable AOFFI.
-                expr += '0';
+                expr += "ftoi(" + Visit(operand) + ')';
            }
            if (index + 1 < aoffi.size()) {
                expr += ", ";
@@ -1651,7 +1645,6 @@ private:
        return name + '_' + std::to_string(index) + '_' + suffix;
    }

-    const Device& device;
    const ShaderIR& ir;
    const ShaderStage stage;
    const std::string suffix;
@@ -1683,9 +1676,8 @@ std::string GetCommonDeclarations() {
           "}\n";
 }

-ProgramResult Decompile(const Device& device, const ShaderIR& ir, Maxwell::ShaderStage stage,
-                        const std::string& suffix) {
-    GLSLDecompiler decompiler(device, ir, stage, suffix);
+ProgramResult Decompile(const ShaderIR& ir, Maxwell::ShaderStage stage, const std::string& suffix) {
+    GLSLDecompiler decompiler(ir, stage, suffix);
    decompiler.Decompile();
    return {decompiler.GetResult(), decompiler.GetShaderEntries()};
 }
@@ -12,10 +12,6 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/shader/shader_ir.h"

-namespace OpenGL {
-class Device;
-}
-
 namespace VideoCommon::Shader {
 class ShaderIR;
 }
@@ -81,7 +77,7 @@ struct ShaderEntries {

 std::string GetCommonDeclarations();

-ProgramResult Decompile(const Device& device, const VideoCommon::Shader::ShaderIR& ir,
-                        Maxwell::ShaderStage stage, const std::string& suffix);
+ProgramResult Decompile(const VideoCommon::Shader::ShaderIR& ir, Maxwell::ShaderStage stage,
+                        const std::string& suffix);

 } // namespace OpenGL::GLShader
@@ -104,8 +104,7 @@ bool ShaderDiskCacheRaw::Save(FileUtil::IOFile& file) const {
    return true;
 }

-ShaderDiskCacheOpenGL::ShaderDiskCacheOpenGL(Core::System& system)
-    : system{system}, precompiled_cache_virtual_file_offset{0} {}
+ShaderDiskCacheOpenGL::ShaderDiskCacheOpenGL(Core::System& system) : system{system} {}

 std::optional<std::pair<std::vector<ShaderDiskCacheRaw>, std::vector<ShaderDiskCacheUsage>>>
 ShaderDiskCacheOpenGL::LoadTransferable() {
@@ -178,7 +177,6 @@ ShaderDiskCacheOpenGL::LoadTransferable() {
            return {};
        }
    }
-
    return {{raws, usages}};
 }

@@ -210,64 +208,59 @@ ShaderDiskCacheOpenGL::LoadPrecompiled() {
 std::optional<std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
                        std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
 ShaderDiskCacheOpenGL::LoadPrecompiledFile(FileUtil::IOFile& file) {
-    // Read compressed file from disk and decompress to virtual precompiled cache file
-    std::vector<u8> compressed(file.GetSize());
-    file.ReadBytes(compressed.data(), compressed.size());
-    const std::vector<u8> decompressed = Common::Compression::DecompressDataZSTD(compressed);
-    SaveArrayToPrecompiled(decompressed.data(), decompressed.size());
-    precompiled_cache_virtual_file_offset = 0;
-
    ShaderCacheVersionHash file_hash{};
-    if (!LoadArrayFromPrecompiled(file_hash.data(), file_hash.size())) {
-        precompiled_cache_virtual_file_offset = 0;
+    if (file.ReadArray(file_hash.data(), file_hash.size()) != file_hash.size()) {
        return {};
    }
    if (GetShaderCacheVersionHash() != file_hash) {
        LOG_INFO(Render_OpenGL, "Precompiled cache is from another version of the emulator");
-        precompiled_cache_virtual_file_offset = 0;
        return {};
    }

    std::unordered_map<u64, ShaderDiskCacheDecompiled> decompiled;
    std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump> dumps;
-    while (precompiled_cache_virtual_file_offset < precompiled_cache_virtual_file.GetSize()) {
+    while (file.Tell() < file.GetSize()) {
        PrecompiledEntryKind kind{};
-        if (!LoadObjectFromPrecompiled(kind)) {
+        if (file.ReadBytes(&kind, sizeof(u32)) != sizeof(u32)) {
            return {};
        }

        switch (kind) {
        case PrecompiledEntryKind::Decompiled: {
            u64 unique_identifier{};
-            if (!LoadObjectFromPrecompiled(unique_identifier)) {
+            if (file.ReadBytes(&unique_identifier, sizeof(u64)) != sizeof(u64))
                return {};
-            }

-            const auto entry = LoadDecompiledEntry();
-            if (!entry) {
+            const auto entry = LoadDecompiledEntry(file);
+            if (!entry)
                return {};
-            }
            decompiled.insert({unique_identifier, std::move(*entry)});
            break;
        }
        case PrecompiledEntryKind::Dump: {
            ShaderDiskCacheUsage usage;
-            if (!LoadObjectFromPrecompiled(usage)) {
+            if (file.ReadBytes(&usage, sizeof(usage)) != sizeof(usage))
                return {};
-            }

            ShaderDiskCacheDump dump;
-            if (!LoadObjectFromPrecompiled(dump.binary_format)) {
+            if (file.ReadBytes(&dump.binary_format, sizeof(u32)) != sizeof(u32))
                return {};
-            }

            u32 binary_length{};
-            if (!LoadObjectFromPrecompiled(binary_length)) {
+            u32 compressed_size{};
+            if (file.ReadBytes(&binary_length, sizeof(u32)) != sizeof(u32) ||
+                file.ReadBytes(&compressed_size, sizeof(u32)) != sizeof(u32)) {
                return {};
            }

-            dump.binary.resize(binary_length);
-            if (!LoadArrayFromPrecompiled(dump.binary.data(), dump.binary.size())) {
+            std::vector<u8> compressed_binary(compressed_size);
+            if (file.ReadArray(compressed_binary.data(), compressed_binary.size()) !=
+                compressed_binary.size()) {
+                return {};
+            }
+
+            dump.binary = Common::Compression::DecompressDataZSTD(compressed_binary);
+            if (dump.binary.empty()) {
                return {};
            }

@@ -281,41 +274,45 @@ ShaderDiskCacheOpenGL::LoadPrecompiledFile(FileUtil::IOFile& file) {
    return {{decompiled, dumps}};
 }

-std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEntry() {
+std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEntry(
+    FileUtil::IOFile& file) {
    u32 code_size{};
-    if (!LoadObjectFromPrecompiled(code_size)) {
+    u32 compressed_code_size{};
+    if (file.ReadBytes(&code_size, sizeof(u32)) != sizeof(u32) ||
+        file.ReadBytes(&compressed_code_size, sizeof(u32)) != sizeof(u32)) {
        return {};
    }

-    std::vector<u8> code(code_size);
-    if (!LoadArrayFromPrecompiled(code.data(), code.size())) {
+    std::vector<u8> compressed_code(compressed_code_size);
+    if (file.ReadArray(compressed_code.data(), compressed_code.size()) != compressed_code.size()) {
        return {};
    }

+    const std::vector<u8> code = Common::Compression::DecompressDataZSTD(compressed_code);
+    if (code.empty()) {
+        return {};
+    }
    ShaderDiskCacheDecompiled entry;
    entry.code = std::string(reinterpret_cast<const char*>(code.data()), code_size);

    u32 const_buffers_count{};
-    if (!LoadObjectFromPrecompiled(const_buffers_count)) {
+    if (file.ReadBytes(&const_buffers_count, sizeof(u32)) != sizeof(u32))
        return {};
-    }
-
    for (u32 i = 0; i < const_buffers_count; ++i) {
        u32 max_offset{};
        u32 index{};
        u8 is_indirect{};
-        if (!LoadObjectFromPrecompiled(max_offset) || !LoadObjectFromPrecompiled(index) ||
-            !LoadObjectFromPrecompiled(is_indirect)) {
+        if (file.ReadBytes(&max_offset, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&index, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&is_indirect, sizeof(u8)) != sizeof(u8)) {
            return {};
        }
        entry.entries.const_buffers.emplace_back(max_offset, is_indirect != 0, index);
    }

    u32 samplers_count{};
-    if (!LoadObjectFromPrecompiled(samplers_count)) {
+    if (file.ReadBytes(&samplers_count, sizeof(u32)) != sizeof(u32))
        return {};
-    }
-
    for (u32 i = 0; i < samplers_count; ++i) {
        u64 offset{};
        u64 index{};
@@ -323,9 +320,12 @@ std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEn
        u8 is_array{};
        u8 is_shadow{};
        u8 is_bindless{};
-        if (!LoadObjectFromPrecompiled(offset) || !LoadObjectFromPrecompiled(index) ||
-            !LoadObjectFromPrecompiled(type) || !LoadObjectFromPrecompiled(is_array) ||
-            !LoadObjectFromPrecompiled(is_shadow) || !LoadObjectFromPrecompiled(is_bindless)) {
+        if (file.ReadBytes(&offset, sizeof(u64)) != sizeof(u64) ||
+            file.ReadBytes(&index, sizeof(u64)) != sizeof(u64) ||
+            file.ReadBytes(&type, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&is_array, sizeof(u8)) != sizeof(u8) ||
+            file.ReadBytes(&is_shadow, sizeof(u8)) != sizeof(u8) ||
+            file.ReadBytes(&is_bindless, sizeof(u8)) != sizeof(u8)) {
            return {};
        }
        entry.entries.samplers.emplace_back(static_cast<std::size_t>(offset),
@@ -335,17 +335,17 @@ std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEn
    }

    u32 global_memory_count{};
-    if (!LoadObjectFromPrecompiled(global_memory_count)) {
+    if (file.ReadBytes(&global_memory_count, sizeof(u32)) != sizeof(u32))
        return {};
-    }
-
    for (u32 i = 0; i < global_memory_count; ++i) {
        u32 cbuf_index{};
        u32 cbuf_offset{};
        u8 is_read{};
        u8 is_written{};
-        if (!LoadObjectFromPrecompiled(cbuf_index) || !LoadObjectFromPrecompiled(cbuf_offset) ||
-            !LoadObjectFromPrecompiled(is_read) || !LoadObjectFromPrecompiled(is_written)) {
+        if (file.ReadBytes(&cbuf_index, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&cbuf_offset, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&is_read, sizeof(u8)) != sizeof(u8) ||
+            file.ReadBytes(&is_written, sizeof(u8)) != sizeof(u8)) {
            return {};
        }
        entry.entries.global_memory_entries.emplace_back(cbuf_index, cbuf_offset, is_read != 0,
@@ -354,81 +354,74 @@ std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEn

    for (auto& clip_distance : entry.entries.clip_distances) {
        u8 clip_distance_raw{};
-        if (!LoadObjectFromPrecompiled(clip_distance_raw))
+        if (file.ReadBytes(&clip_distance_raw, sizeof(u8)) != sizeof(u8))
            return {};
        clip_distance = clip_distance_raw != 0;
    }

    u64 shader_length{};
-    if (!LoadObjectFromPrecompiled(shader_length)) {
+    if (file.ReadBytes(&shader_length, sizeof(u64)) != sizeof(u64))
        return {};
-    }
-
    entry.entries.shader_length = static_cast<std::size_t>(shader_length);

    return entry;
 }

-bool ShaderDiskCacheOpenGL::SaveDecompiledFile(u64 unique_identifier, const std::string& code,
+bool ShaderDiskCacheOpenGL::SaveDecompiledFile(FileUtil::IOFile& file, u64 unique_identifier,
+                                               const std::string& code,
+                                               const std::vector<u8>& compressed_code,
                                               const GLShader::ShaderEntries& entries) {
-    if (!SaveObjectToPrecompiled(static_cast<u32>(PrecompiledEntryKind::Decompiled)) ||
-        !SaveObjectToPrecompiled(unique_identifier) ||
-        !SaveObjectToPrecompiled(static_cast<u32>(code.size())) ||
-        !SaveArrayToPrecompiled(code.data(), code.size())) {
+    if (file.WriteObject(static_cast<u32>(PrecompiledEntryKind::Decompiled)) != 1 ||
+        file.WriteObject(unique_identifier) != 1 ||
+        file.WriteObject(static_cast<u32>(code.size())) != 1 ||
+        file.WriteObject(static_cast<u32>(compressed_code.size())) != 1 ||
+        file.WriteArray(compressed_code.data(), compressed_code.size()) != compressed_code.size()) {
        return false;
    }

-    if (!SaveObjectToPrecompiled(static_cast<u32>(entries.const_buffers.size()))) {
+    if (file.WriteObject(static_cast<u32>(entries.const_buffers.size())) != 1)
        return false;
-    }
    for (const auto& cbuf : entries.const_buffers) {
-        if (!SaveObjectToPrecompiled(static_cast<u32>(cbuf.GetMaxOffset())) ||
-            !SaveObjectToPrecompiled(static_cast<u32>(cbuf.GetIndex())) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(cbuf.IsIndirect() ? 1 : 0))) {
+        if (file.WriteObject(static_cast<u32>(cbuf.GetMaxOffset())) != 1 ||
+            file.WriteObject(static_cast<u32>(cbuf.GetIndex())) != 1 ||
+            file.WriteObject(static_cast<u8>(cbuf.IsIndirect() ? 1 : 0)) != 1) {
            return false;
        }
    }

-    if (!SaveObjectToPrecompiled(static_cast<u32>(entries.samplers.size()))) {
+    if (file.WriteObject(static_cast<u32>(entries.samplers.size())) != 1)
        return false;
-    }
    for (const auto& sampler : entries.samplers) {
-        if (!SaveObjectToPrecompiled(static_cast<u64>(sampler.GetOffset())) ||
-            !SaveObjectToPrecompiled(static_cast<u64>(sampler.GetIndex())) ||
-            !SaveObjectToPrecompiled(static_cast<u32>(sampler.GetType())) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(sampler.IsArray() ? 1 : 0)) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(sampler.IsShadow() ? 1 : 0)) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(sampler.IsBindless() ? 1 : 0))) {
+        if (file.WriteObject(static_cast<u64>(sampler.GetOffset())) != 1 ||
+            file.WriteObject(static_cast<u64>(sampler.GetIndex())) != 1 ||
+            file.WriteObject(static_cast<u32>(sampler.GetType())) != 1 ||
+            file.WriteObject(static_cast<u8>(sampler.IsArray() ? 1 : 0)) != 1 ||
+            file.WriteObject(static_cast<u8>(sampler.IsShadow() ? 1 : 0)) != 1 ||
+            file.WriteObject(static_cast<u8>(sampler.IsBindless() ? 1 : 0)) != 1) {
            return false;
        }
    }

-    if (!SaveObjectToPrecompiled(static_cast<u32>(entries.global_memory_entries.size()))) {
+    if (file.WriteObject(static_cast<u32>(entries.global_memory_entries.size())) != 1)
        return false;
-    }
    for (const auto& gmem : entries.global_memory_entries) {
-        if (!SaveObjectToPrecompiled(static_cast<u32>(gmem.GetCbufIndex())) ||
-            !SaveObjectToPrecompiled(static_cast<u32>(gmem.GetCbufOffset())) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(gmem.IsRead() ? 1 : 0)) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(gmem.IsWritten() ? 1 : 0))) {
+        if (file.WriteObject(static_cast<u32>(gmem.GetCbufIndex())) != 1 ||
+            file.WriteObject(static_cast<u32>(gmem.GetCbufOffset())) != 1 ||
+            file.WriteObject(static_cast<u8>(gmem.IsRead() ? 1 : 0)) != 1 ||
+            file.WriteObject(static_cast<u8>(gmem.IsWritten() ? 1 : 0)) != 1) {
            return false;
        }
    }

    for (const bool clip_distance : entries.clip_distances) {
-        if (!SaveObjectToPrecompiled(static_cast<u8>(clip_distance ? 1 : 0))) {
+        if (file.WriteObject(static_cast<u8>(clip_distance ? 1 : 0)) != 1)
            return false;
-        }
    }

-    if (!SaveObjectToPrecompiled(static_cast<u64>(entries.shader_length))) {
-        return false;
-    }
-
-    return true;
+    return file.WriteObject(static_cast<u64>(entries.shader_length)) == 1;
 }

-void ShaderDiskCacheOpenGL::InvalidateTransferable() {
+void ShaderDiskCacheOpenGL::InvalidateTransferable() const {
    if (!FileUtil::Delete(GetTransferablePath())) {
        LOG_ERROR(Render_OpenGL, "Failed to invalidate transferable file={}",
                  GetTransferablePath());
@@ -436,10 +429,7 @@ void ShaderDiskCacheOpenGL::InvalidateTransferable() {
    InvalidatePrecompiled();
 }

-void ShaderDiskCacheOpenGL::InvalidatePrecompiled() {
-    // Clear virtaul precompiled cache file
-    precompiled_cache_virtual_file.Resize(0);
-
+void ShaderDiskCacheOpenGL::InvalidatePrecompiled() const {
    if (!FileUtil::Delete(GetPrecompiledPath())) {
        LOG_ERROR(Render_OpenGL, "Failed to invalidate precompiled file={}", GetPrecompiledPath());
    }
@@ -495,13 +485,22 @@ void ShaderDiskCacheOpenGL::SaveDecompiled(u64 unique_identifier, const std::str
    if (!IsUsable())
        return;

-    if (precompiled_cache_virtual_file.GetSize() == 0) {
-        SavePrecompiledHeaderToVirtualPrecompiledCache();
+    const std::vector<u8> compressed_code{Common::Compression::CompressDataZSTDDefault(
+        reinterpret_cast<const u8*>(code.data()), code.size())};
+    if (compressed_code.empty()) {
+        LOG_ERROR(Render_OpenGL, "Failed to compress GLSL code - skipping shader {:016x}",
+                  unique_identifier);
+        return;
    }

-    if (!SaveDecompiledFile(unique_identifier, code, entries)) {
+    FileUtil::IOFile file = AppendPrecompiledFile();
+    if (!file.IsOpen())
+        return;
+
+    if (!SaveDecompiledFile(file, unique_identifier, code, compressed_code, entries)) {
        LOG_ERROR(Render_OpenGL,
                  "Failed to save decompiled entry to the precompiled file - removing");
+        file.Close();
        InvalidatePrecompiled();
    }
 }
@@ -517,13 +516,28 @@ void ShaderDiskCacheOpenGL::SaveDump(const ShaderDiskCacheUsage& usage, GLuint p
    std::vector<u8> binary(binary_length);
    glGetProgramBinary(program, binary_length, nullptr, &binary_format, binary.data());

-    if (!SaveObjectToPrecompiled(static_cast<u32>(PrecompiledEntryKind::Dump)) ||
-        !SaveObjectToPrecompiled(usage) ||
-        !SaveObjectToPrecompiled(static_cast<u32>(binary_format)) ||
-        !SaveObjectToPrecompiled(static_cast<u32>(binary_length)) ||
-        !SaveArrayToPrecompiled(binary.data(), binary.size())) {
+    const std::vector<u8> compressed_binary =
+        Common::Compression::CompressDataZSTDDefault(binary.data(), binary.size());
+
+    if (compressed_binary.empty()) {
+        LOG_ERROR(Render_OpenGL, "Failed to compress binary program in shader={:016x}",
+                  usage.unique_identifier);
+        return;
+    }
+
+    FileUtil::IOFile file = AppendPrecompiledFile();
+    if (!file.IsOpen())
+        return;
+
+    if (file.WriteObject(static_cast<u32>(PrecompiledEntryKind::Dump)) != 1 ||
+        file.WriteObject(usage) != 1 || file.WriteObject(static_cast<u32>(binary_format)) != 1 ||
+        file.WriteObject(static_cast<u32>(binary_length)) != 1 ||
+        file.WriteObject(static_cast<u32>(compressed_binary.size())) != 1 ||
+        file.WriteArray(compressed_binary.data(), compressed_binary.size()) !=
+            compressed_binary.size()) {
        LOG_ERROR(Render_OpenGL, "Failed to save binary program file in shader={:016x} - removing",
                  usage.unique_identifier);
+        file.Close();
        InvalidatePrecompiled();
        return;
    }
@@ -556,33 +570,28 @@ FileUtil::IOFile ShaderDiskCacheOpenGL::AppendTransferableFile() const {
    return file;
 }

-void ShaderDiskCacheOpenGL::SavePrecompiledHeaderToVirtualPrecompiledCache() {
-    const auto hash{GetShaderCacheVersionHash()};
-    if (!SaveArrayToPrecompiled(hash.data(), hash.size())) {
-        LOG_ERROR(
-            Render_OpenGL,
-            "Failed to write precompiled cache version hash to virtual precompiled cache file");
-    }
-}
-
-void ShaderDiskCacheOpenGL::SaveVirtualPrecompiledFile() {
-    precompiled_cache_virtual_file_offset = 0;
-    const std::vector<u8>& uncompressed = precompiled_cache_virtual_file.ReadAllBytes();
-    const std::vector<u8>& compressed =
-        Common::Compression::CompressDataZSTDDefault(uncompressed.data(), uncompressed.size());
+FileUtil::IOFile ShaderDiskCacheOpenGL::AppendPrecompiledFile() const {
+    if (!EnsureDirectories())
+        return {};

    const auto precompiled_path{GetPrecompiledPath()};
-    FileUtil::IOFile file(precompiled_path, "wb");
+    const bool existed = FileUtil::Exists(precompiled_path);

+    FileUtil::IOFile file(precompiled_path, "ab");
    if (!file.IsOpen()) {
        LOG_ERROR(Render_OpenGL, "Failed to open precompiled cache in path={}", precompiled_path);
-        return;
+        return {};
    }
-    if (file.WriteBytes(compressed.data(), compressed.size()) != compressed.size()) {
-        LOG_ERROR(Render_OpenGL, "Failed to write precompiled cache version in path={}",
-                  precompiled_path);
-        return;
+
+    if (!existed || file.GetSize() == 0) {
+        const auto hash{GetShaderCacheVersionHash()};
+        if (file.WriteArray(hash.data(), hash.size()) != hash.size()) {
+            LOG_ERROR(Render_OpenGL, "Failed to write precompiled cache version hash in path={}",
+                      precompiled_path);
+            return {};
+        }
    }
+    return file;
 }

 bool ShaderDiskCacheOpenGL::EnsureDirectories() const {
@@ -16,7 +16,6 @@

 #include "common/assert.h"
 #include "common/common_types.h"
-#include "core/file_sys/vfs_vector.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"

@@ -173,10 +172,10 @@ public:
    LoadPrecompiled();

    /// Removes the transferable (and precompiled) cache file.
-    void InvalidateTransferable();
+    void InvalidateTransferable() const;

-    /// Removes the precompiled cache file and clears virtual precompiled cache file.
-    void InvalidatePrecompiled();
+    /// Removes the precompiled cache file.
+    void InvalidatePrecompiled() const;

    /// Saves a raw dump to the transferable file. Checks for collisions.
    void SaveRaw(const ShaderDiskCacheRaw& entry);
@@ -191,21 +190,18 @@ public:
    /// Saves a dump entry to the precompiled file. Does not check for collisions.
    void SaveDump(const ShaderDiskCacheUsage& usage, GLuint program);

-    /// Serializes virtual precompiled shader cache file to real file
-    void SaveVirtualPrecompiledFile();
-
 private:
    /// Loads the transferable cache. Returns empty on failure.
    std::optional<std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
                            std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
    LoadPrecompiledFile(FileUtil::IOFile& file);

-    /// Loads a decompiled cache entry from m_precompiled_cache_virtual_file. Returns empty on
-    /// failure.
-    std::optional<ShaderDiskCacheDecompiled> LoadDecompiledEntry();
+    /// Loads a decompiled cache entry from the passed file. Returns empty on failure.
+    std::optional<ShaderDiskCacheDecompiled> LoadDecompiledEntry(FileUtil::IOFile& file);

    /// Saves a decompiled entry to the passed file. Returns true on success.
-    bool SaveDecompiledFile(u64 unique_identifier, const std::string& code,
+    bool SaveDecompiledFile(FileUtil::IOFile& file, u64 unique_identifier, const std::string& code,
+                            const std::vector<u8>& compressed_code,
                            const GLShader::ShaderEntries& entries);

    /// Returns if the cache can be used
@@ -214,8 +210,8 @@ private:
    /// Opens current game's transferable file and write it's header if it doesn't exist
    FileUtil::IOFile AppendTransferableFile() const;

-    /// Save precompiled header to precompiled_cache_in_memory
-    void SavePrecompiledHeaderToVirtualPrecompiledCache();
+    /// Opens current game's precompiled file and write it's header if it doesn't exist
+    FileUtil::IOFile AppendPrecompiledFile() const;

    /// Create shader disk cache directories. Returns true on success.
    bool EnsureDirectories() const;
@@ -238,42 +234,10 @@ private:
    /// Get current game's title id
    std::string GetTitleID() const;

-    template <typename T>
-    bool SaveArrayToPrecompiled(const T* data, std::size_t length) {
-        const std::size_t write_length = precompiled_cache_virtual_file.WriteArray(
-            data, length, precompiled_cache_virtual_file_offset);
-        precompiled_cache_virtual_file_offset += write_length;
-        return write_length == sizeof(T) * length;
-    }
-
-    template <typename T>
-    bool LoadArrayFromPrecompiled(T* data, std::size_t length) {
-        const std::size_t read_length = precompiled_cache_virtual_file.ReadArray(
-            data, length, precompiled_cache_virtual_file_offset);
-        precompiled_cache_virtual_file_offset += read_length;
-        return read_length == sizeof(T) * length;
-    }
-
-    template <typename T>
-    bool SaveObjectToPrecompiled(const T& object) {
-        return SaveArrayToPrecompiled(&object, 1);
-    }
-
-    template <typename T>
-    bool LoadObjectFromPrecompiled(T& object) {
-        return LoadArrayFromPrecompiled(&object, 1);
-    }
-
    // Copre system
    Core::System& system;
    // Stored transferable shaders
    std::map<u64, std::unordered_set<ShaderDiskCacheUsage>> transferable;
-    // Stores whole precompiled cache which will be read from or saved to the precompiled chache
-    // file
-    FileSys::VectorVfsFile precompiled_cache_virtual_file;
-    // Stores the current offset of the precompiled cache file for IO purposes
-    std::size_t precompiled_cache_virtual_file_offset;
-
    // The cache has been loaded at boot
    bool tried_to_load{};
 };
@@ -16,7 +16,7 @@ using VideoCommon::Shader::ShaderIR;

 static constexpr u32 PROGRAM_OFFSET{10};

-ProgramResult GenerateVertexShader(const Device& device, const ShaderSetup& setup) {
+ProgramResult GenerateVertexShader(const ShaderSetup& setup) {
    const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);

    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
@@ -34,15 +34,14 @@ layout (std140, binding = EMULATION_UBO_BINDING) uniform vs_config {

 )";
    ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET);
-    ProgramResult program =
-        Decompile(device, program_ir, Maxwell3D::Regs::ShaderStage::Vertex, "vertex");
+    ProgramResult program = Decompile(program_ir, Maxwell3D::Regs::ShaderStage::Vertex, "vertex");

    out += program.first;

    if (setup.IsDualProgram()) {
        ShaderIR program_ir_b(setup.program.code_b, PROGRAM_OFFSET);
        ProgramResult program_b =
-            Decompile(device, program_ir_b, Maxwell3D::Regs::ShaderStage::Vertex, "vertex_b");
+            Decompile(program_ir_b, Maxwell3D::Regs::ShaderStage::Vertex, "vertex_b");

        out += program_b.first;
    }
@@ -58,9 +57,6 @@ void main() {
    }

    out += R"(
-
-    // Set Position Y direction
-    position.y *= utof(config_pack[2]);
    // Check if the flip stage is VertexB
    // Config pack's second value is flip_stage
    if (config_pack[1] == 1) {
@@ -79,7 +75,7 @@ void main() {
    return {out, program.second};
 }

-ProgramResult GenerateGeometryShader(const Device& device, const ShaderSetup& setup) {
+ProgramResult GenerateGeometryShader(const ShaderSetup& setup) {
    const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);

    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
@@ -99,7 +95,7 @@ layout (std140, binding = EMULATION_UBO_BINDING) uniform gs_config {
 )";
    ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET);
    ProgramResult program =
-        Decompile(device, program_ir, Maxwell3D::Regs::ShaderStage::Geometry, "geometry");
+        Decompile(program_ir, Maxwell3D::Regs::ShaderStage::Geometry, "geometry");
    out += program.first;

    out += R"(
@@ -110,7 +106,7 @@ void main() {
    return {out, program.second};
 }

-ProgramResult GenerateFragmentShader(const Device& device, const ShaderSetup& setup) {
+ProgramResult GenerateFragmentShader(const ShaderSetup& setup) {
    const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);

    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
@@ -162,7 +158,7 @@ bool AlphaFunc(in float value) {
 )";
    ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET);
    ProgramResult program =
-        Decompile(device, program_ir, Maxwell3D::Regs::ShaderStage::Fragment, "fragment");
+        Decompile(program_ir, Maxwell3D::Regs::ShaderStage::Fragment, "fragment");

    out += program.first;

@@ -10,10 +10,6 @@
 #include "video_core/renderer_opengl/gl_shader_decompiler.h"
 #include "video_core/shader/shader_ir.h"

-namespace OpenGL {
-class Device;
-}
-
 namespace OpenGL::GLShader {

 using VideoCommon::Shader::ProgramCode;
@@ -43,13 +39,22 @@ private:
    bool has_program_b{};
 };

-/// Generates the GLSL vertex shader program source code for the given VS program
-ProgramResult GenerateVertexShader(const Device& device, const ShaderSetup& setup);
+/**
+ * Generates the GLSL vertex shader program source code for the given VS program
+ * @returns String of the shader source code
+ */
+ProgramResult GenerateVertexShader(const ShaderSetup& setup);

-/// Generates the GLSL geometry shader program source code for the given GS program
-ProgramResult GenerateGeometryShader(const Device& device, const ShaderSetup& setup);
+/**
+ * Generates the GLSL geometry shader program source code for the given GS program
+ * @returns String of the shader source code
+ */
+ProgramResult GenerateGeometryShader(const ShaderSetup& setup);

-/// Generates the GLSL fragment shader program source code for the given FS program
-ProgramResult GenerateFragmentShader(const Device& device, const ShaderSetup& setup);
+/**
+ * Generates the GLSL fragment shader program source code for the given FS program
+ * @returns String of the shader source code
+ */
+ProgramResult GenerateFragmentShader(const ShaderSetup& setup);

 } // namespace OpenGL::GLShader
@@ -471,9 +471,8 @@ void OpenGLState::ApplyTextures() const {
        const auto& texture_unit = texture_units[i];
        auto& cur_state_texture_unit = cur_state.texture_units[i];
        textures[i] = texture_unit.texture;
-        if (cur_state_texture_unit.texture == textures[i]) {
+        if (cur_state_texture_unit.texture == textures[i])
            continue;
-        }
        cur_state_texture_unit.texture = textures[i];
        if (!has_delta) {
            first = i;
@@ -494,11 +493,10 @@ void OpenGLState::ApplySamplers() const {
    std::array<GLuint, Maxwell::NumTextureSamplers> samplers;

    for (std::size_t i = 0; i < std::size(samplers); ++i) {
-        samplers[i] = texture_units[i].sampler;
-        if (cur_state.texture_units[i].sampler == texture_units[i].sampler) {
+        if (cur_state.texture_units[i].sampler == texture_units[i].sampler)
            continue;
-        }
        cur_state.texture_units[i].sampler = texture_units[i].sampler;
+        samplers[i] = texture_units[i].sampler;
        if (!has_delta) {
            first = i;
            has_delta = true;
@@ -27,7 +27,8 @@ using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
    switch (attrib.type) {
    case Maxwell::VertexAttribute::Type::UnsignedInt:
-    case Maxwell::VertexAttribute::Type::UnsignedNorm:
+    case Maxwell::VertexAttribute::Type::UnsignedNorm: {
+
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_8:
        case Maxwell::VertexAttribute::Size::Size_8_8:
@@ -46,13 +47,16 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
            return GL_UNSIGNED_INT;
        case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
            return GL_UNSIGNED_INT_2_10_10_10_REV;
-        default:
-            LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
-            UNREACHABLE();
-            return {};
        }
+
+        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
+        UNREACHABLE();
+        return {};
+    }
+
    case Maxwell::VertexAttribute::Type::SignedInt:
-    case Maxwell::VertexAttribute::Type::SignedNorm:
+    case Maxwell::VertexAttribute::Type::SignedNorm: {
+
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_8:
        case Maxwell::VertexAttribute::Size::Size_8_8:
@@ -71,12 +75,14 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
            return GL_INT;
        case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
            return GL_INT_2_10_10_10_REV;
-        default:
-            LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
-            UNREACHABLE();
-            return {};
        }
-    case Maxwell::VertexAttribute::Type::Float:
+
+        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
+        UNREACHABLE();
+        return {};
+    }
+
+    case Maxwell::VertexAttribute::Type::Float: {
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_16:
        case Maxwell::VertexAttribute::Size::Size_16_16:
@@ -88,16 +94,13 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
        case Maxwell::VertexAttribute::Size::Size_32_32_32:
        case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
            return GL_FLOAT;
-        default:
-            LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
-            UNREACHABLE();
-            return {};
        }
-    default:
-        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex type={}", attrib.TypeString());
-        UNREACHABLE();
-        return {};
    }
+    }
+
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex type={}", attrib.TypeString());
+    UNREACHABLE();
+    return {};
 }

 inline GLenum IndexFormat(Maxwell::IndexFormat index_format) {
@@ -126,11 +129,10 @@ inline GLenum PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
        return GL_TRIANGLES;
    case Maxwell::PrimitiveTopology::TriangleStrip:
        return GL_TRIANGLE_STRIP;
-    default:
-        LOG_CRITICAL(Render_OpenGL, "Unimplemented topology={}", static_cast<u32>(topology));
-        UNREACHABLE();
-        return {};
    }
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented topology={}", static_cast<u32>(topology));
+    UNREACHABLE();
+    return {};
 }

 inline GLenum TextureFilterMode(Tegra::Texture::TextureFilter filter_mode,
@@ -184,10 +186,9 @@ inline GLenum WrapMode(Tegra::Texture::WrapMode wrap_mode) {
        } else {
            return GL_MIRROR_CLAMP_TO_EDGE;
        }
-    default:
-        LOG_ERROR(Render_OpenGL, "Unimplemented texture wrap mode={}", static_cast<u32>(wrap_mode));
-        return GL_REPEAT;
    }
+    LOG_ERROR(Render_OpenGL, "Unimplemented texture wrap mode={}", static_cast<u32>(wrap_mode));
+    return GL_REPEAT;
 }

 inline GLenum DepthCompareFunc(Tegra::Texture::DepthCompareFunc func) {
@@ -62,10 +62,9 @@ vk::SamplerAddressMode WrapMode(Tegra::Texture::WrapMode wrap_mode) {
    case Tegra::Texture::WrapMode::MirrorOnceBorder:
        UNIMPLEMENTED();
        return vk::SamplerAddressMode::eMirrorClampToEdge;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented wrap mode={}", static_cast<u32>(wrap_mode));
-        return {};
    }
+    UNIMPLEMENTED_MSG("Unimplemented wrap mode={}", static_cast<u32>(wrap_mode));
+    return {};
 }

 vk::CompareOp DepthCompareFunction(Tegra::Texture::DepthCompareFunc depth_compare_func) {
@@ -226,10 +225,9 @@ vk::PrimitiveTopology PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
        return vk::PrimitiveTopology::eTriangleList;
    case Maxwell::PrimitiveTopology::TriangleStrip:
        return vk::PrimitiveTopology::eTriangleStrip;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented topology={}", static_cast<u32>(topology));
-        return {};
    }
+    UNIMPLEMENTED_MSG("Unimplemented topology={}", static_cast<u32>(topology));
+    return {};
 }

 vk::Format VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttribute::Size size) {
@@ -116,8 +116,6 @@ ExitMethod ShaderIR::Scan(u32 begin, u32 end, std::set<u32>& labels) {
            // Continue scanning for an exit method.
            break;
        }
-        default:
-            break;
        }
    }
    return exit_method = ExitMethod::AlwaysReturn;
@@ -208,4 +206,4 @@ u32 ShaderIR::DecodeInstr(NodeBlock& bb, u32 pc) {
    return pc + 1;
 }

-} // namespace VideoCommon::Shader
+} // namespace VideoCommon::Shader
@@ -9,7 +9,6 @@

 namespace VideoCommon::Shader {

-using Tegra::Shader::HalfType;
 using Tegra::Shader::Instruction;
 using Tegra::Shader::OpCode;

@@ -23,6 +22,7 @@ u32 ShaderIR::DecodeArithmeticHalf(NodeBlock& bb, u32 pc) {
            LOG_WARNING(HW_GPU, "{} FTZ not implemented", opcode->get().GetName());
        }
    }
+    UNIMPLEMENTED_IF_MSG(instr.alu_half.saturate != 0, "Half float saturation not implemented");

    const bool negate_a =
        opcode->get().GetId() != OpCode::Id::HMUL2_R && instr.alu_half.negate_a != 0;
@@ -32,37 +32,35 @@ u32 ShaderIR::DecodeArithmeticHalf(NodeBlock& bb, u32 pc) {
    Node op_a = UnpackHalfFloat(GetRegister(instr.gpr8), instr.alu_half.type_a);
    op_a = GetOperandAbsNegHalf(op_a, instr.alu_half.abs_a, negate_a);

-    auto [type_b, op_b] = [&]() -> std::tuple<HalfType, Node> {
+    Node op_b = [&]() {
        switch (opcode->get().GetId()) {
        case OpCode::Id::HADD2_C:
        case OpCode::Id::HMUL2_C:
-            return {HalfType::F32, GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset())};
+            return GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset());
        case OpCode::Id::HADD2_R:
        case OpCode::Id::HMUL2_R:
-            return {instr.alu_half.type_b, GetRegister(instr.gpr20)};
+            return GetRegister(instr.gpr20);
        default:
            UNREACHABLE();
-            return {HalfType::F32, Immediate(0)};
+            return Immediate(0);
        }
    }();
-    op_b = UnpackHalfFloat(op_b, type_b);
-    // redeclaration to avoid a bug in clang with reusing local bindings in lambdas
-    Node op_b_alt = GetOperandAbsNegHalf(op_b, instr.alu_half.abs_b, negate_b);
+    op_b = UnpackHalfFloat(op_b, instr.alu_half.type_b);
+    op_b = GetOperandAbsNegHalf(op_b, instr.alu_half.abs_b, negate_b);

    Node value = [&]() {
        switch (opcode->get().GetId()) {
        case OpCode::Id::HADD2_C:
        case OpCode::Id::HADD2_R:
-            return Operation(OperationCode::HAdd, PRECISE, op_a, op_b_alt);
+            return Operation(OperationCode::HAdd, PRECISE, op_a, op_b);
        case OpCode::Id::HMUL2_C:
        case OpCode::Id::HMUL2_R:
-            return Operation(OperationCode::HMul, PRECISE, op_a, op_b_alt);
+            return Operation(OperationCode::HMul, PRECISE, op_a, op_b);
        default:
            UNIMPLEMENTED_MSG("Unhandled half float instruction: {}", opcode->get().GetName());
            return Immediate(0);
        }
    }();
-    value = GetSaturatedHalfFloat(value, instr.alu_half.saturate);
    value = HalfMerge(GetRegister(instr.gpr0), value, instr.alu_half.merge);

    SetRegister(bb, instr.gpr0, value);
@@ -70,4 +68,4 @@ u32 ShaderIR::DecodeArithmeticHalf(NodeBlock& bb, u32 pc) {
    return pc;
 }

-} // namespace VideoCommon::Shader
+} // namespace VideoCommon::Shader
@@ -120,11 +120,10 @@ u32 ShaderIR::DecodeConversion(NodeBlock& bb, u32 pc) {
                return Operation(OperationCode::FCeil, PRECISE, value);
            case Tegra::Shader::F2fRoundingOp::Trunc:
                return Operation(OperationCode::FTrunc, PRECISE, value);
-            default:
-                UNIMPLEMENTED_MSG("Unimplemented F2F rounding mode {}",
-                                  static_cast<u32>(instr.conversion.f2f.rounding.Value()));
-                return Immediate(0);
            }
+            UNIMPLEMENTED_MSG("Unimplemented F2F rounding mode {}",
+                              static_cast<u32>(instr.conversion.f2f.rounding.Value()));
+            return Immediate(0);
        }();
        value = GetSaturatedFloat(value, instr.alu.saturate_d);

@@ -34,14 +34,15 @@ u32 ShaderIR::DecodeHfma2(NodeBlock& bb, u32 pc) {
        case OpCode::Id::HFMA2_CR:
            neg_b = instr.hfma2.negate_b;
            neg_c = instr.hfma2.negate_c;
-            return {instr.hfma2.saturate, HalfType::F32,
+            return {instr.hfma2.saturate, instr.hfma2.type_b,
                    GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset()),
                    instr.hfma2.type_reg39, GetRegister(instr.gpr39)};
        case OpCode::Id::HFMA2_RC:
            neg_b = instr.hfma2.negate_b;
            neg_c = instr.hfma2.negate_c;
            return {instr.hfma2.saturate, instr.hfma2.type_reg39, GetRegister(instr.gpr39),
-                    HalfType::F32, GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset())};
+                    instr.hfma2.type_b,
+                    GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset())};
        case OpCode::Id::HFMA2_RR:
            neg_b = instr.hfma2.rr.negate_b;
            neg_c = instr.hfma2.rr.negate_c;
@@ -55,13 +56,13 @@ u32 ShaderIR::DecodeHfma2(NodeBlock& bb, u32 pc) {
            return {false, identity, Immediate(0), identity, Immediate(0)};
        }
    }();
+    UNIMPLEMENTED_IF_MSG(saturate, "HFMA2 saturation is not implemented");

    const Node op_a = UnpackHalfFloat(GetRegister(instr.gpr8), instr.hfma2.type_a);
    op_b = GetOperandAbsNegHalf(UnpackHalfFloat(op_b, type_b), false, neg_b);
    op_c = GetOperandAbsNegHalf(UnpackHalfFloat(op_c, type_c), false, neg_c);

    Node value = Operation(OperationCode::HFma, PRECISE, op_a, op_b, op_c);
-    value = GetSaturatedHalfFloat(value, saturate);
    value = HalfMerge(GetRegister(instr.gpr0), value, instr.hfma2.merge);

    SetRegister(bb, instr.gpr0, value);
@@ -69,4 +70,4 @@ u32 ShaderIR::DecodeHfma2(NodeBlock& bb, u32 pc) {
    return pc;
 }

-} // namespace VideoCommon::Shader
+} // namespace VideoCommon::Shader
@@ -296,7 +296,7 @@ const Sampler& ShaderIR::GetBindlessSampler(const Tegra::Shader::Register& reg,
    ASSERT(cbuf_offset_imm != nullptr);
    const auto cbuf_offset = cbuf_offset_imm->GetValue();
    const auto cbuf_index = cbuf->GetIndex();
-    const auto cbuf_key = (static_cast<u64>(cbuf_index) << 32) | static_cast<u64>(cbuf_offset);
+    const u64 cbuf_key = (cbuf_index << 32) | cbuf_offset;

    // If this sampler has already been used, return the existing mapping.
    const auto itr =
@@ -56,10 +56,9 @@ u32 ShaderIR::DecodeXmad(NodeBlock& bb, u32 pc) {
                    instr.xmad.mode,
                    Immediate(static_cast<u32>(instr.xmad.imm20_16)),
                    GetRegister(instr.gpr39)};
-        default:
-            UNIMPLEMENTED_MSG("Unhandled XMAD instruction: {}", opcode->get().GetName());
-            return {false, false, false, Tegra::Shader::XmadMode::None, Immediate(0), Immediate(0)};
        }
+        UNIMPLEMENTED_MSG("Unhandled XMAD instruction: {}", opcode->get().GetName());
+        return {false, false, false, Tegra::Shader::XmadMode::None, Immediate(0), Immediate(0)};
    }();

    op_a = BitfieldExtract(op_a, instr.xmad.high_a ? 16 : 0, 16);
@@ -439,14 +439,11 @@ Node ShaderIR::BitfieldExtract(Node value, u32 offset, u32 bits) {
        return OperationCode::LogicalUGreaterEqual;
    case OperationCode::INegate:
        UNREACHABLE_MSG("Can't negate an unsigned integer");
-        return {};
    case OperationCode::IAbsolute:
        UNREACHABLE_MSG("Can't apply absolute to an unsigned integer");
-        return {};
-    default:
-        UNREACHABLE_MSG("Unknown signed operation with code={}", static_cast<u32>(operation_code));
-        return {};
    }
+    UNREACHABLE_MSG("Unknown signed operation with code={}", static_cast<u32>(operation_code));
+    return {};
 }

-} // namespace VideoCommon::Shader
+} // namespace VideoCommon::Shader
@@ -251,9 +251,8 @@ public:
    }

    bool operator<(const Sampler& rhs) const {
-        return std::tie(index, offset, type, is_array, is_shadow, is_bindless) <
-               std::tie(rhs.index, rhs.offset, rhs.type, rhs.is_array, rhs.is_shadow,
-                        rhs.is_bindless);
+        return std::tie(offset, index, type, is_array, is_shadow) <
+               std::tie(rhs.offset, rhs.index, rhs.type, rhs.is_array, rhs.is_shadow);
    }

 private:
@@ -178,44 +178,39 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::ABGR8S;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::ABGR8UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::B5G6R5:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::B5G6R5U;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::A2B10G10R10:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::A2B10G10R10U;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::A1B5G5R5:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::A1B5G5R5U;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R8:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::R8U;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::R8UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::G8R8:
        // TextureFormat::G8R8 is actually ordered red then green, as such we can use
        // PixelFormat::RG8U and PixelFormat::RG8S. This was tested with The Legend of Zelda: Breath
@@ -225,55 +220,50 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::RG8U;
        case Tegra::Texture::ComponentType::SNORM:
            return PixelFormat::RG8S;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R16_G16_B16_A16:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::RGBA16U;
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::RGBA16F;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::BF10GF11RF11:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::R11FG11FB10F;
-        default:
-            break;
        }
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R32_G32_B32_A32:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::RGBA32F;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::RGBA32UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R32_G32:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::RG32F;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::RG32UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R32_G32_B32:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::RGB32F;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R16:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
@@ -286,20 +276,18 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::R16UI;
        case Tegra::Texture::ComponentType::SINT:
            return PixelFormat::R16I;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R32:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::R32F;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::R32UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::ZF32:
        return PixelFormat::Z32F;
    case Tegra::Texture::TextureFormat::Z16:
@@ -322,10 +310,9 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::DXN2UNORM;
        case Tegra::Texture::ComponentType::SNORM:
            return PixelFormat::DXN2SNORM;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::BC7U:
        return is_srgb ? PixelFormat::BC7U_SRGB : PixelFormat::BC7U;
    case Tegra::Texture::TextureFormat::BC6H_UF16:
@@ -356,17 +343,15 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::RG16UI;
        case Tegra::Texture::ComponentType::SINT:
            return PixelFormat::RG16I;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    default:
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented format={}, component_type={}", static_cast<u32>(format),
+                     static_cast<u32>(component_type));
+        UNREACHABLE();
+        return PixelFormat::ABGR8U;
    }
-    LOG_CRITICAL(HW_GPU, "Unimplemented format={}, component_type={}", static_cast<u32>(format),
-                 static_cast<u32>(component_type));
-    UNREACHABLE();
-    return PixelFormat::ABGR8U;
 }

 ComponentType ComponentTypeFromTexture(Tegra::Texture::ComponentType type) {
@@ -528,9 +513,8 @@ bool IsFormatBCn(PixelFormat format) {
    case PixelFormat::DXT45_SRGB:
    case PixelFormat::BC7U_SRGB:
        return true;
-    default:
-        return false;
    }
+    return false;
 }

 } // namespace VideoCore::Surface
@@ -7,8 +7,6 @@ add_executable(yuzu
    Info.plist
    about_dialog.cpp
    about_dialog.h
-    applets/error.cpp
-    applets/error.h
    applets/profile_select.cpp
    applets/profile_select.h
    applets/software_keyboard.cpp
@@ -1,59 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <QDateTime>
-#include "core/hle/lock.h"
-#include "yuzu/applets/error.h"
-#include "yuzu/main.h"
-
-QtErrorDisplay::QtErrorDisplay(GMainWindow& parent) {
-    connect(this, &QtErrorDisplay::MainWindowDisplayError, &parent,
-            &GMainWindow::ErrorDisplayDisplayError, Qt::QueuedConnection);
-    connect(&parent, &GMainWindow::ErrorDisplayFinished, this,
-            &QtErrorDisplay::MainWindowFinishedError, Qt::DirectConnection);
-}
-
-QtErrorDisplay::~QtErrorDisplay() = default;
-
-void QtErrorDisplay::ShowError(ResultCode error, std::function<void()> finished) const {
-    this->callback = std::move(finished);
-    emit MainWindowDisplayError(
-        tr("An error has occured.\nPlease try again or contact the developer of the "
-           "software.\n\nError Code: %1-%2 (0x%3)")
-            .arg(static_cast<u32>(error.module.Value()) + 2000, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.description, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.raw, 8, 16, QChar::fromLatin1('0')));
-}
-
-void QtErrorDisplay::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                            std::function<void()> finished) const {
-    this->callback = std::move(finished);
-    emit MainWindowDisplayError(
-        tr("An error occured on %1 at %2.\nPlease try again or contact the "
-           "developer of the software.\n\nError Code: %3-%4 (0x%5)")
-            .arg(QDateTime::fromSecsSinceEpoch(time.count()).toString("dddd, MMMM d, yyyy"))
-            .arg(QDateTime::fromSecsSinceEpoch(time.count()).toString("h:mm:ss A"))
-            .arg(static_cast<u32>(error.module.Value()) + 2000, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.description, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.raw, 8, 16, QChar::fromLatin1('0')));
-}
-
-void QtErrorDisplay::ShowCustomErrorText(ResultCode error, std::string dialog_text,
-                                         std::string fullscreen_text,
-                                         std::function<void()> finished) const {
-    this->callback = std::move(finished);
-    emit MainWindowDisplayError(
-        tr("An error has occured.\nError Code: %1-%2 (0x%3)\n\n%4\n\n%5")
-            .arg(static_cast<u32>(error.module.Value()) + 2000, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.description, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.raw, 8, 16, QChar::fromLatin1('0'))
-            .arg(QString::fromStdString(dialog_text))
-            .arg(QString::fromStdString(fullscreen_text)));
-}
-
-void QtErrorDisplay::MainWindowFinishedError() {
-    // Acquire the HLE mutex
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
-    callback();
-}
@@ -1,33 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <QObject>
-
-#include "core/frontend/applets/error.h"
-
-class GMainWindow;
-
-class QtErrorDisplay final : public QObject, public Core::Frontend::ErrorApplet {
-    Q_OBJECT
-
-public:
-    explicit QtErrorDisplay(GMainWindow& parent);
-    ~QtErrorDisplay() override;
-
-    void ShowError(ResultCode error, std::function<void()> finished) const override;
-    void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                std::function<void()> finished) const override;
-    void ShowCustomErrorText(ResultCode error, std::string dialog_text, std::string fullscreen_text,
-                             std::function<void()> finished) const override;
-
-signals:
-    void MainWindowDisplayError(QString error) const;
-
-private:
-    void MainWindowFinishedError();
-
-    mutable std::function<void()> callback;
-};
@@ -377,11 +377,7 @@ void GRenderWindow::InitRenderTarget() {
    // WA_DontShowOnScreen, WA_DeleteOnClose
    QSurfaceFormat fmt;
    fmt.setVersion(4, 3);
-    if (Settings::values.use_compatibility_profile) {
-        fmt.setProfile(QSurfaceFormat::CompatibilityProfile);
-    } else {
-        fmt.setProfile(QSurfaceFormat::CoreProfile);
-    }
+    fmt.setProfile(QSurfaceFormat::CoreProfile);
    // TODO: expose a setting for buffer value (ie default/single/double/triple)
    fmt.setSwapBehavior(QSurfaceFormat::DefaultSwapBehavior);
    shared_context = std::make_unique<QOpenGLContext>();
@@ -389,8 +389,6 @@ void Config::ReadValues() {
    Settings::values.resolution_factor = ReadSetting("resolution_factor", 1.0).toFloat();
    Settings::values.use_frame_limit = ReadSetting("use_frame_limit", true).toBool();
    Settings::values.frame_limit = ReadSetting("frame_limit", 100).toInt();
-    Settings::values.use_compatibility_profile =
-        ReadSetting("use_compatibility_profile", true).toBool();
    Settings::values.use_disk_shader_cache = ReadSetting("use_disk_shader_cache", true).toBool();
    Settings::values.use_accurate_gpu_emulation =
        ReadSetting("use_accurate_gpu_emulation", false).toBool();
@@ -663,7 +661,6 @@ void Config::SaveValues() {
    WriteSetting("resolution_factor", (double)Settings::values.resolution_factor, 1.0);
    WriteSetting("use_frame_limit", Settings::values.use_frame_limit, true);
    WriteSetting("frame_limit", Settings::values.frame_limit, 100);
-    WriteSetting("use_compatibility_profile", Settings::values.use_compatibility_profile, true);
    WriteSetting("use_disk_shader_cache", Settings::values.use_disk_shader_cache, true);
    WriteSetting("use_accurate_gpu_emulation", Settings::values.use_accurate_gpu_emulation, false);
    WriteSetting("use_asynchronous_gpu_emulation", Settings::values.use_asynchronous_gpu_emulation,
@@ -73,7 +73,6 @@ void ConfigureGraphics::setConfiguration() {
        static_cast<int>(FromResolutionFactor(Settings::values.resolution_factor)));
    ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit);
    ui->frame_limit->setValue(Settings::values.frame_limit);
-    ui->use_compatibility_profile->setChecked(Settings::values.use_compatibility_profile);
    ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache);
    ui->use_accurate_gpu_emulation->setChecked(Settings::values.use_accurate_gpu_emulation);
    ui->use_asynchronous_gpu_emulation->setEnabled(!Core::System::GetInstance().IsPoweredOn());
@@ -89,7 +88,6 @@ void ConfigureGraphics::applyConfiguration() {
        ToResolutionFactor(static_cast<Resolution>(ui->resolution_factor_combobox->currentIndex()));
    Settings::values.use_frame_limit = ui->toggle_frame_limit->isChecked();
    Settings::values.frame_limit = ui->frame_limit->value();
-    Settings::values.use_compatibility_profile = ui->use_compatibility_profile->isChecked();
    Settings::values.use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
    Settings::values.use_accurate_gpu_emulation = ui->use_accurate_gpu_emulation->isChecked();
    Settings::values.use_asynchronous_gpu_emulation =
@@ -49,13 +49,6 @@
          </item>
         </layout>
        </item>
-        <item>
-         <widget class="QCheckBox" name="use_compatibility_profile">
-          <property name="text">
-           <string>Use OpenGL compatibility profile</string>
-          </property>
-         </widget>
-        </item>
        <item>
         <widget class="QCheckBox" name="use_disk_shader_cache">
          <property name="text">
@@ -227,7 +227,8 @@ QString WaitTreeThread::GetText() const {
    case Kernel::ThreadStatus::WaitIPC:
        status = tr("waiting for IPC reply");
        break;
-    case Kernel::ThreadStatus::WaitSynch:
+    case Kernel::ThreadStatus::WaitSynchAll:
+    case Kernel::ThreadStatus::WaitSynchAny:
        status = tr("waiting for objects");
        break;
    case Kernel::ThreadStatus::WaitMutex:
@@ -268,7 +269,8 @@ QColor WaitTreeThread::GetColor() const {
        return QColor(Qt::GlobalColor::darkRed);
    case Kernel::ThreadStatus::WaitSleep:
        return QColor(Qt::GlobalColor::darkYellow);
-    case Kernel::ThreadStatus::WaitSynch:
+    case Kernel::ThreadStatus::WaitSynchAll:
+    case Kernel::ThreadStatus::WaitSynchAny:
    case Kernel::ThreadStatus::WaitMutex:
    case Kernel::ThreadStatus::WaitCondVar:
    case Kernel::ThreadStatus::WaitArb:
@@ -323,9 +325,10 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
        list.push_back(std::make_unique<WaitTreeText>(tr("not waiting for mutex")));
    }

-    if (thread.GetStatus() == Kernel::ThreadStatus::WaitSynch) {
+    if (thread.GetStatus() == Kernel::ThreadStatus::WaitSynchAny ||
+        thread.GetStatus() == Kernel::ThreadStatus::WaitSynchAll) {
        list.push_back(std::make_unique<WaitTreeObjectList>(thread.GetWaitObjects(),
-                                                            thread.IsSleepingOnWait()));
+                                                            thread.IsSleepingOnWaitAll()));
    }

    list.push_back(std::make_unique<WaitTreeCallstack>(thread));
@@ -8,7 +8,6 @@
 #include <thread>

 // VFS includes must be before glad as they will conflict with Windows file api, which uses defines.
-#include "applets/error.h"
 #include "applets/profile_select.h"
 #include "applets/software_keyboard.h"
 #include "applets/web_browser.h"
@@ -16,7 +15,6 @@
 #include "configuration/configure_per_general.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/frontend/applets/general_frontend.h"
 #include "core/frontend/scope_acquire_window_context.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/applets/applets.h"
@@ -797,13 +795,9 @@ bool GMainWindow::LoadROM(const QString& filename) {

    system.SetGPUDebugContext(debug_context);

-    system.SetAppletFrontendSet({
-        std::make_unique<QtErrorDisplay>(*this),
-        nullptr,
-        std::make_unique<QtProfileSelector>(*this),
-        std::make_unique<QtSoftwareKeyboard>(*this),
-        std::make_unique<QtWebBrowser>(*this),
-    });
+    system.SetProfileSelector(std::make_unique<QtProfileSelector>(*this));
+    system.SetSoftwareKeyboard(std::make_unique<QtSoftwareKeyboard>(*this));
+    system.SetWebBrowser(std::make_unique<QtWebBrowser>(*this));

    const Core::System::ResultStatus result{system.Load(*render_window, filename.toStdString())};

@@ -1589,11 +1583,6 @@ void GMainWindow::OnLoadComplete() {
    loading_screen->OnLoadComplete();
 }

-void GMainWindow::ErrorDisplayDisplayError(QString body) {
-    QMessageBox::critical(this, tr("Error Display"), body);
-    emit ErrorDisplayFinished();
-}
-
 void GMainWindow::OnMenuReportCompatibility() {
    if (!Settings::values.yuzu_token.empty() && !Settings::values.yuzu_username.empty()) {
        CompatDB compatdb{this};
@@ -102,8 +102,6 @@ signals:
    // Signal that tells widgets to update icons to use the current theme
    void UpdateThemedIcons();

-    void ErrorDisplayFinished();
-
    void ProfileSelectorFinishedSelection(std::optional<Service::Account::UUID> uuid);
    void SoftwareKeyboardFinishedText(std::optional<std::u16string> text);
    void SoftwareKeyboardFinishedCheckDialog();
@@ -113,7 +111,6 @@ signals:

 public slots:
    void OnLoadComplete();
-    void ErrorDisplayDisplayError(QString body);
    void ProfileSelectorSelectProfile();
    void SoftwareKeyboardGetText(const Core::Frontend::SoftwareKeyboardParameters& parameters);
    void SoftwareKeyboardInvokeCheckDialog(std::u16string error_message);
@@ -349,8 +349,6 @@ void Config::ReadValues() {
    Settings::values.use_frame_limit = sdl2_config->GetBoolean("Renderer", "use_frame_limit", true);
    Settings::values.frame_limit =
        static_cast<u16>(sdl2_config->GetInteger("Renderer", "frame_limit", 100));
-    Settings::values.use_compatibility_profile =
-        sdl2_config->GetBoolean("Renderer", "use_compatibility_profile", true);
    Settings::values.use_disk_shader_cache =
        sdl2_config->GetBoolean("Renderer", "use_disk_shader_cache", false);
    Settings::values.use_accurate_gpu_emulation =
@@ -32,7 +32,11 @@
 #include "yuzu_cmd/config.h"
 #include "yuzu_cmd/emu_window/emu_window_sdl2.h"

+#include <getopt.h>
 #include "core/file_sys/registered_cache.h"
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif

 #ifdef _WIN32
 // windows.h needs to be included before shellapi.h
@@ -41,12 +45,6 @@
 #include <shellapi.h>
 #endif

-#undef _UNICODE
-#include <getopt.h>
-#ifndef _MSC_VER
-#include <unistd.h>
-#endif
-
 #ifdef _WIN32
 extern "C" {
 // tells Nvidia and AMD drivers to use the dedicated GPU by default on laptops with switchable
Author	SHA1	Message	Date
Fernando Sahmkow	e64c41efe8	Refactors and name corrections.	2019-05-01 15:31:39 -04:00
Fernando Sahmkow	b3118ee316	Fixes and Corrections to DMA Engine	2019-04-23 15:28:18 -04:00
Fernando Sahmkow	f1e5314f1a	Add Swizzle Parameters to the DMA engine	2019-04-23 11:21:00 -04:00
Fernando Sahmkow	e140e2ebc6	Add Documentation Headers to all the GPU Engines	2019-04-23 08:44:52 -04:00
Fernando Sahmkow	021d28c9b8	Corrections and styling	2019-04-23 08:02:24 -04:00
Fernando Sahmkow	701ce1c9d0	Implement Maxwell3D Data Upload	2019-04-22 19:27:36 -04:00
Fernando Sahmkow	e4ff140b99	Introduce skeleton of the GPU Compute Engine.	2019-04-22 19:05:43 -04:00
Fernando Sahmkow	a91d3fc639	Revamp Kepler Memory to use a subegine to manage uploads	2019-04-22 18:50:56 -04:00