Multiple viewports are only valid while using geometry shaders so avoid uploading states that can be potentially invalid.

fix Clear viewport area by calculating overlapping area when viewport and scissor are enabled at the same time.
add warning messages for extension that are not required but are needed for a correct emulation.

CMakeLists.txt

@@ -377,7 +377,7 @@ if (CLANG_FORMAT)
     set(CCOMMENT "Running clang format against all the .h and .cpp files in src/")
     if (WIN32)
         add_custom_target(clang-format
-            COMMAND powershell.exe -Command "Get-ChildItem ${SRCS}/* -Include *.cpp,*.h -Recurse | Foreach {${CLANG_FORMAT} -i $_.fullname}"
+            COMMAND powershell.exe -Command "${CLANG_FORMAT} -i @(Get-ChildItem -Recurse ${SRCS}/* -Include \'*.h\', \'*.cpp\')"
             COMMENT ${CCOMMENT})
     elseif(MINGW)
         add_custom_target(clang-format

src/common/thread.cpp

@@ -25,6 +25,23 @@
 
 namespace Common {
 
+int CurrentThreadId() {
+#ifdef _MSC_VER
+    return GetCurrentThreadId();
+#elif defined __APPLE__
+    return mach_thread_self();
+#else
+    return 0;
+#endif
+}
+
+#ifdef _WIN32
+// Supporting functions
+void SleepCurrentThread(int ms) {
+    Sleep(ms);
+}
+#endif
+
 #ifdef _MSC_VER
 
 void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask) {
@@ -45,7 +62,7 @@ void SwitchCurrentThread() {
 
 // This is implemented much nicer in upcoming msvc++, see:
 // http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.100).aspx
-void SetCurrentThreadName(const char* name) {
+void SetCurrentThreadName(const char* szThreadName) {
     static const DWORD MS_VC_EXCEPTION = 0x406D1388;
 
 #pragma pack(push, 8)
@@ -58,7 +75,7 @@ void SetCurrentThreadName(const char* name) {
 #pragma pack(pop)
 
     info.dwType = 0x1000;
-    info.szName = name;
+    info.szName = szThreadName;
     info.dwThreadID = -1; // dwThreadID;
     info.dwFlags = 0;
 
@@ -90,6 +107,10 @@ void SetCurrentThreadAffinity(u32 mask) {
 }
 
 #ifndef _WIN32
+void SleepCurrentThread(int ms) {
+    usleep(1000 * ms);
+}
+
 void SwitchCurrentThread() {
     usleep(1000 * 1);
 }
@@ -97,15 +118,15 @@ void SwitchCurrentThread() {
 
 // MinGW with the POSIX threading model does not support pthread_setname_np
 #if !defined(_WIN32) || defined(_MSC_VER)
-void SetCurrentThreadName(const char* name) {
+void SetCurrentThreadName(const char* szThreadName) {
 #ifdef __APPLE__
-    pthread_setname_np(name);
+    pthread_setname_np(szThreadName);
 #elif defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
-    pthread_set_name_np(pthread_self(), name);
+    pthread_set_name_np(pthread_self(), szThreadName);
 #elif defined(__NetBSD__)
-    pthread_setname_np(pthread_self(), "%s", (void*)name);
+    pthread_setname_np(pthread_self(), "%s", (void*)szThreadName);
 #else
-    pthread_setname_np(pthread_self(), name);
+    pthread_setname_np(pthread_self(), szThreadName);
 #endif
 }
 #endif

src/common/thread.h

@@ -13,8 +13,15 @@
 
 namespace Common {
 
+int CurrentThreadId();
+
+void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);
+void SetCurrentThreadAffinity(u32 mask);
+
 class Event {
 public:
+    Event() : is_set(false) {}
+
     void Set() {
         std::lock_guard<std::mutex> lk(mutex);
         if (!is_set) {
@@ -46,14 +53,14 @@ public:
     }
 
 private:
-    bool is_set = false;
+    bool is_set;
     std::condition_variable condvar;
     std::mutex mutex;
 };
 
 class Barrier {
 public:
-    explicit Barrier(std::size_t count_) : count(count_) {}
+    explicit Barrier(std::size_t count_) : count(count_), waiting(0), generation(0) {}
 
     /// Blocks until all "count" threads have called Sync()
     void Sync() {
@@ -73,13 +80,12 @@ public:
 private:
     std::condition_variable condvar;
     std::mutex mutex;
-    std::size_t count;
-    std::size_t waiting = 0;
-    std::size_t generation = 0; // Incremented once each time the barrier is used
+    const std::size_t count;
+    std::size_t waiting;
+    std::size_t generation; // Incremented once each time the barrier is used
 };
 
-void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);
-void SetCurrentThreadAffinity(u32 mask);
+void SleepCurrentThread(int ms);
 void SwitchCurrentThread(); // On Linux, this is equal to sleep 1ms
 void SetCurrentThreadName(const char* name);
 

src/core/CMakeLists.txt

@@ -12,8 +12,6 @@ add_library(core STATIC
     core_timing.h
     core_timing_util.cpp
     core_timing_util.h
-    cpu_core_manager.cpp
-    cpu_core_manager.h
     crypto/aes_util.cpp
     crypto/aes_util.h
     crypto/encryption_layer.cpp
@@ -158,8 +156,6 @@ add_library(core STATIC
     hle/service/am/applets/applets.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/idle.cpp
     hle/service/am/idle.h
     hle/service/am/omm.cpp

src/core/core.cpp

@@ -14,7 +14,6 @@
 #include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
-#include "core/cpu_core_manager.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
@@ -29,6 +28,7 @@
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/perf_stats.h"
+#include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "frontend/applets/software_keyboard.h"
 #include "video_core/debug_utils/debug_utils.h"
@@ -71,22 +71,64 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
+
+/// Runs a CPU core while the system is powered on
+void RunCpuCore(Cpu& cpu_state) {
+    while (Core::System::GetInstance().IsPoweredOn()) {
+        cpu_state.RunLoop(true);
+    }
+}
 } // Anonymous namespace
 
 struct System::Impl {
     Cpu& CurrentCpuCore() {
-        return cpu_core_manager.GetCurrentCore();
+        if (Settings::values.use_multi_core) {
+            const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+            ASSERT(search != thread_to_cpu.end());
+            ASSERT(search->second);
+            return *search->second;
+        }
+
+        // Otherwise, use single-threaded mode active_core variable
+        return *cpu_cores[active_core];
     }
 
     ResultStatus RunLoop(bool tight_loop) {
         status = ResultStatus::Success;
 
-        cpu_core_manager.RunLoop(tight_loop);
+        // Update thread_to_cpu in case Core 0 is run from a different host thread
+        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0].get();
+
+        if (GDBStub::IsServerEnabled()) {
+            GDBStub::HandlePacket();
+
+            // If the loop is halted and we want to step, use a tiny (1) number of instructions to
+            // execute. Otherwise, get out of the loop function.
+            if (GDBStub::GetCpuHaltFlag()) {
+                if (GDBStub::GetCpuStepFlag()) {
+                    tight_loop = false;
+                } else {
+                    return ResultStatus::Success;
+                }
+            }
+        }
+
+        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
+            cpu_cores[active_core]->RunLoop(tight_loop);
+            if (Settings::values.use_multi_core) {
+                // Cores 1-3 are run on other threads in this mode
+                break;
+            }
+        }
+
+        if (GDBStub::IsServerEnabled()) {
+            GDBStub::SetCpuStepFlag(false);
+        }
 
         return status;
     }
 
-    ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
+    ResultStatus Init(Frontend::EmuWindow& emu_window) {
         LOG_DEBUG(HW_Memory, "initialized OK");
 
         CoreTiming::Init();
@@ -103,6 +145,12 @@ struct System::Impl {
         auto main_process = Kernel::Process::Create(kernel, "main");
         kernel.MakeCurrentProcess(main_process.get());
 
+        cpu_barrier = std::make_unique<CpuBarrier>();
+        cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
+        for (std::size_t index = 0; index < cpu_cores.size(); ++index) {
+            cpu_cores[index] = std::make_unique<Cpu>(*cpu_exclusive_monitor, *cpu_barrier, index);
+        }
+
         telemetry_session = std::make_unique<Core::TelemetrySession>();
         service_manager = std::make_shared<Service::SM::ServiceManager>();
 
@@ -116,8 +164,17 @@ struct System::Impl {
 
         gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
 
-        cpu_core_manager.Initialize(system);
-        is_powered_on = true;
+        // Create threads for CPU cores 1-3, and build thread_to_cpu map
+        // CPU core 0 is run on the main thread
+        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0].get();
+        if (Settings::values.use_multi_core) {
+            for (std::size_t index = 0; index < cpu_core_threads.size(); ++index) {
+                cpu_core_threads[index] =
+                    std::make_unique<std::thread>(RunCpuCore, std::ref(*cpu_cores[index + 1]));
+                thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1].get();
+            }
+        }
+
         LOG_DEBUG(Core, "Initialized OK");
 
         // Reset counters and set time origin to current frame
@@ -127,8 +184,7 @@ struct System::Impl {
         return ResultStatus::Success;
     }
 
-    ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
-                      const std::string& filepath) {
+    ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
         app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
 
         if (!app_loader) {
@@ -145,7 +201,7 @@ struct System::Impl {
             return ResultStatus::ErrorSystemMode;
         }
 
-        ResultStatus init_result{Init(system, emu_window)};
+        ResultStatus init_result{Init(emu_window)};
         if (init_result != ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                          static_cast<int>(init_result));
@@ -175,8 +231,6 @@ struct System::Impl {
         Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
                              perf_results.frametime * 1000.0);
 
-        is_powered_on = false;
-
         // Shutdown emulation session
         renderer.reset();
         GDBStub::Shutdown();
@@ -186,7 +240,19 @@ struct System::Impl {
         gpu_core.reset();
 
         // Close all CPU/threading state
-        cpu_core_manager.Shutdown();
+        cpu_barrier->NotifyEnd();
+        if (Settings::values.use_multi_core) {
+            for (auto& thread : cpu_core_threads) {
+                thread->join();
+                thread.reset();
+            }
+        }
+        thread_to_cpu.clear();
+        for (auto& cpu_core : cpu_cores) {
+            cpu_core.reset();
+        }
+        cpu_exclusive_monitor.reset();
+        cpu_barrier.reset();
 
         // Shutdown kernel and core timing
         kernel.Shutdown();
@@ -223,8 +289,11 @@ struct System::Impl {
     std::unique_ptr<VideoCore::RendererBase> renderer;
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::shared_ptr<Tegra::DebugContext> debug_context;
-    CpuCoreManager cpu_core_manager;
-    bool is_powered_on = false;
+    std::unique_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
+    std::unique_ptr<CpuBarrier> cpu_barrier;
+    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
+    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;
+    std::size_t active_core{}; ///< Active core, only used in single thread mode
 
     /// Frontend applets
     std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
@@ -238,6 +307,9 @@ struct System::Impl {
     ResultStatus status = ResultStatus::Success;
     std::string status_details = "";
 
+    /// Map of guest threads to CPU cores
+    std::map<std::thread::id, Cpu*> thread_to_cpu;
+
     Core::PerfStats perf_stats;
     Core::FrameLimiter frame_limiter;
 };
@@ -262,15 +334,17 @@ System::ResultStatus System::SingleStep() {
 }
 
 void System::InvalidateCpuInstructionCaches() {
-    impl->cpu_core_manager.InvalidateAllInstructionCaches();
+    for (auto& cpu : impl->cpu_cores) {
+        cpu->ArmInterface().ClearInstructionCache();
+    }
 }
 
 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-    return impl->Load(*this, emu_window, filepath);
+    return impl->Load(emu_window, filepath);
 }
 
 bool System::IsPoweredOn() const {
-    return impl->is_powered_on;
+    return impl->cpu_barrier && impl->cpu_barrier->IsAlive();
 }
 
 void System::PrepareReschedule() {
@@ -334,20 +408,21 @@ const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
 }
 
 Cpu& System::CpuCore(std::size_t core_index) {
-    return impl->cpu_core_manager.GetCore(core_index);
+    ASSERT(core_index < NUM_CPU_CORES);
+    return *impl->cpu_cores[core_index];
 }
 
 const Cpu& System::CpuCore(std::size_t core_index) const {
     ASSERT(core_index < NUM_CPU_CORES);
-    return impl->cpu_core_manager.GetCore(core_index);
+    return *impl->cpu_cores[core_index];
 }
 
 ExclusiveMonitor& System::Monitor() {
-    return impl->cpu_core_manager.GetExclusiveMonitor();
+    return *impl->cpu_exclusive_monitor;
 }
 
 const ExclusiveMonitor& System::Monitor() const {
-    return impl->cpu_core_manager.GetExclusiveMonitor();
+    return *impl->cpu_exclusive_monitor;
 }
 
 Tegra::GPU& System::GPU() {
@@ -431,7 +506,7 @@ const Core::Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() cons
 }
 
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
-    return impl->Init(*this, emu_window);
+    return impl->Init(emu_window);
 }
 
 void System::Shutdown() {

src/core/cpu_core_manager.cpp

@@ -1,142 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "core/arm/exclusive_monitor.h"
-#include "core/core.h"
-#include "core/core_cpu.h"
-#include "core/cpu_core_manager.h"
-#include "core/gdbstub/gdbstub.h"
-#include "core/settings.h"
-
-namespace Core {
-namespace {
-void RunCpuCore(const System& system, Cpu& cpu_state) {
-    while (system.IsPoweredOn()) {
-        cpu_state.RunLoop(true);
-    }
-}
-} // Anonymous namespace
-
-CpuCoreManager::CpuCoreManager() = default;
-CpuCoreManager::~CpuCoreManager() = default;
-
-void CpuCoreManager::Initialize(System& system) {
-    barrier = std::make_unique<CpuBarrier>();
-    exclusive_monitor = Cpu::MakeExclusiveMonitor(cores.size());
-
-    for (std::size_t index = 0; index < cores.size(); ++index) {
-        cores[index] = std::make_unique<Cpu>(*exclusive_monitor, *barrier, index);
-    }
-
-    // Create threads for CPU cores 1-3, and build thread_to_cpu map
-    // CPU core 0 is run on the main thread
-    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
-    if (!Settings::values.use_multi_core) {
-        return;
-    }
-
-    for (std::size_t index = 0; index < core_threads.size(); ++index) {
-        core_threads[index] = std::make_unique<std::thread>(RunCpuCore, std::cref(system),
-                                                            std::ref(*cores[index + 1]));
-        thread_to_cpu[core_threads[index]->get_id()] = cores[index + 1].get();
-    }
-}
-
-void CpuCoreManager::Shutdown() {
-    barrier->NotifyEnd();
-    if (Settings::values.use_multi_core) {
-        for (auto& thread : core_threads) {
-            thread->join();
-            thread.reset();
-        }
-    }
-
-    thread_to_cpu.clear();
-    for (auto& cpu_core : cores) {
-        cpu_core.reset();
-    }
-
-    exclusive_monitor.reset();
-    barrier.reset();
-}
-
-Cpu& CpuCoreManager::GetCore(std::size_t index) {
-    return *cores.at(index);
-}
-
-const Cpu& CpuCoreManager::GetCore(std::size_t index) const {
-    return *cores.at(index);
-}
-
-ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() {
-    return *exclusive_monitor;
-}
-
-const ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() const {
-    return *exclusive_monitor;
-}
-
-Cpu& CpuCoreManager::GetCurrentCore() {
-    if (Settings::values.use_multi_core) {
-        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
-        ASSERT(search != thread_to_cpu.end());
-        ASSERT(search->second);
-        return *search->second;
-    }
-
-    // Otherwise, use single-threaded mode active_core variable
-    return *cores[active_core];
-}
-
-const Cpu& CpuCoreManager::GetCurrentCore() const {
-    if (Settings::values.use_multi_core) {
-        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
-        ASSERT(search != thread_to_cpu.end());
-        ASSERT(search->second);
-        return *search->second;
-    }
-
-    // Otherwise, use single-threaded mode active_core variable
-    return *cores[active_core];
-}
-
-void CpuCoreManager::RunLoop(bool tight_loop) {
-    // Update thread_to_cpu in case Core 0 is run from a different host thread
-    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
-
-    if (GDBStub::IsServerEnabled()) {
-        GDBStub::HandlePacket();
-
-        // If the loop is halted and we want to step, use a tiny (1) number of instructions to
-        // execute. Otherwise, get out of the loop function.
-        if (GDBStub::GetCpuHaltFlag()) {
-            if (GDBStub::GetCpuStepFlag()) {
-                tight_loop = false;
-            } else {
-                return;
-            }
-        }
-    }
-
-    for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
-        cores[active_core]->RunLoop(tight_loop);
-        if (Settings::values.use_multi_core) {
-            // Cores 1-3 are run on other threads in this mode
-            break;
-        }
-    }
-
-    if (GDBStub::IsServerEnabled()) {
-        GDBStub::SetCpuStepFlag(false);
-    }
-}
-
-void CpuCoreManager::InvalidateAllInstructionCaches() {
-    for (auto& cpu : cores) {
-        cpu->ArmInterface().ClearInstructionCache();
-    }
-}
-
-} // namespace Core

src/core/cpu_core_manager.h

@@ -1,59 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <map>
-#include <memory>
-#include <thread>
-
-namespace Core {
-
-class Cpu;
-class CpuBarrier;
-class ExclusiveMonitor;
-class System;
-
-class CpuCoreManager {
-public:
-    CpuCoreManager();
-    CpuCoreManager(const CpuCoreManager&) = delete;
-    CpuCoreManager(CpuCoreManager&&) = delete;
-
-    ~CpuCoreManager();
-
-    CpuCoreManager& operator=(const CpuCoreManager&) = delete;
-    CpuCoreManager& operator=(CpuCoreManager&&) = delete;
-
-    void Initialize(System& system);
-    void Shutdown();
-
-    Cpu& GetCore(std::size_t index);
-    const Cpu& GetCore(std::size_t index) const;
-
-    Cpu& GetCurrentCore();
-    const Cpu& GetCurrentCore() const;
-
-    ExclusiveMonitor& GetExclusiveMonitor();
-    const ExclusiveMonitor& GetExclusiveMonitor() const;
-
-    void RunLoop(bool tight_loop);
-
-    void InvalidateAllInstructionCaches();
-
-private:
-    static constexpr std::size_t NUM_CPU_CORES = 4;
-
-    std::unique_ptr<ExclusiveMonitor> exclusive_monitor;
-    std::unique_ptr<CpuBarrier> barrier;
-    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cores;
-    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> core_threads;
-    std::size_t active_core{}; ///< Active core, only used in single thread mode
-
-    /// Map of guest threads to CPU cores
-    std::map<std::thread::id, Cpu*> thread_to_cpu;
-};
-
-} // namespace Core

src/core/file_sys/patch_manager.cpp

@@ -26,11 +26,6 @@ namespace FileSys {
 constexpr u64 SINGLE_BYTE_MODULUS = 0x100;
 constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
 
-constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{
-    "main",    "main.npdm", "rtld",    "sdk",     "subsdk0", "subsdk1", "subsdk2",
-    "subsdk3", "subsdk4",   "subsdk5", "subsdk6", "subsdk7", "subsdk8", "subsdk9",
-};
-
 struct NSOBuildHeader {
     u32_le magic;
     INSERT_PADDING_BYTES(0x3C);
@@ -62,15 +57,6 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     if (exefs == nullptr)
         return exefs;
 
-    if (Settings::values.dump_exefs) {
-        LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
-        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
-        if (dump_dir != nullptr) {
-            const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
-            VfsRawCopyD(exefs, exefs_dir);
-        }
-    }
-
     const auto installed = Service::FileSystem::GetUnionContents();
 
     // Game Updates
@@ -84,30 +70,6 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
         exefs = update->GetExeFS();
     }
 
-    // LayeredExeFS
-    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    if (load_dir != nullptr && load_dir->GetSize() > 0) {
-        auto patch_dirs = load_dir->GetSubdirectories();
-        std::sort(
-            patch_dirs.begin(), patch_dirs.end(),
-            [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
-
-        std::vector<VirtualDir> layers;
-        layers.reserve(patch_dirs.size() + 1);
-        for (const auto& subdir : patch_dirs) {
-            auto exefs_dir = subdir->GetSubdirectory("exefs");
-            if (exefs_dir != nullptr)
-                layers.push_back(std::move(exefs_dir));
-        }
-        layers.push_back(exefs);
-
-        auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
-        if (layered != nullptr) {
-            LOG_INFO(Loader, "    ExeFS: LayeredExeFS patches applied successfully");
-            exefs = std::move(layered);
-        }
-    }
-
     return exefs;
 }
 
@@ -352,25 +314,18 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
             if (IsDirValidAndNonEmpty(exefs_dir)) {
                 bool ips = false;
                 bool ipswitch = false;
-                bool layeredfs = false;
 
                 for (const auto& file : exefs_dir->GetFiles()) {
-                    if (file->GetExtension() == "ips") {
+                    if (file->GetExtension() == "ips")
                         ips = true;
-                    } else if (file->GetExtension() == "pchtxt") {
+                    else if (file->GetExtension() == "pchtxt")
                         ipswitch = true;
-                    } else if (std::find(EXEFS_FILE_NAMES.begin(), EXEFS_FILE_NAMES.end(),
-                                         file->GetName()) != EXEFS_FILE_NAMES.end()) {
-                        layeredfs = true;
-                    }
                 }
 
                 if (ips)
                     AppendCommaIfNotEmpty(types, "IPS");
                 if (ipswitch)
                     AppendCommaIfNotEmpty(types, "IPSwitch");
-                if (layeredfs)
-                    AppendCommaIfNotEmpty(types, "LayeredExeFS");
             }
             if (IsDirValidAndNonEmpty(mod->GetSubdirectory("romfs")))
                 AppendCommaIfNotEmpty(types, "LayeredFS");

src/core/gdbstub/gdbstub.cpp

@@ -71,6 +71,10 @@ constexpr u32 PSTATE_REGISTER = 33;
 constexpr u32 UC_ARM64_REG_Q0 = 34;
 constexpr u32 FPCR_REGISTER = 66;
 
+// TODO/WiP - Used while working on support for FPU
+constexpr u32 TODO_DUMMY_REG_997 = 997;
+constexpr u32 TODO_DUMMY_REG_998 = 998;
+
 // For sample XML files see the GDB source /gdb/features
 // GDB also wants the l character at the start
 // This XML defines what the registers are for this specific ARM device
@@ -256,36 +260,6 @@ static void RegWrite(std::size_t id, u64 val, Kernel::Thread* thread = nullptr)
     }
 }
 
-static u128 FpuRead(std::size_t id, Kernel::Thread* thread = nullptr) {
-    if (!thread) {
-        return u128{0};
-    }
-
-    auto& thread_context = thread->GetContext();
-
-    if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
-        return thread_context.vector_registers[id - UC_ARM64_REG_Q0];
-    } else if (id == FPCR_REGISTER) {
-        return u128{thread_context.fpcr, 0};
-    } else {
-        return u128{0};
-    }
-}
-
-static void FpuWrite(std::size_t id, u128 val, Kernel::Thread* thread = nullptr) {
-    if (!thread) {
-        return;
-    }
-
-    auto& thread_context = thread->GetContext();
-
-    if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
-        thread_context.vector_registers[id - UC_ARM64_REG_Q0] = val;
-    } else if (id == FPCR_REGISTER) {
-        thread_context.fpcr = val[0];
-    }
-}
-
 /**
  * Turns hex string character into the equivalent byte.
  *
@@ -435,27 +409,6 @@ static u64 GdbHexToLong(const u8* src) {
     return output;
 }
 
-/**
- * Convert a gdb-formatted hex string into a u128.
- *
- * @param src Pointer to hex string.
- */
-static u128 GdbHexToU128(const u8* src) {
-    u128 output;
-
-    for (int i = 0; i < 16; i += 2) {
-        output[0] = (output[0] << 4) | HexCharToValue(src[15 - i - 1]);
-        output[0] = (output[0] << 4) | HexCharToValue(src[15 - i]);
-    }
-
-    for (int i = 0; i < 16; i += 2) {
-        output[1] = (output[1] << 4) | HexCharToValue(src[16 + 15 - i - 1]);
-        output[1] = (output[1] << 4) | HexCharToValue(src[16 + 15 - i]);
-    }
-
-    return output;
-}
-
 /// Read a byte from the gdb client.
 static u8 ReadByte() {
     u8 c;
@@ -646,7 +599,8 @@ static void HandleQuery() {
         for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
             const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
             for (const auto& thread : threads) {
-                val += fmt::format("{:x},", thread->GetThreadID());
+                val += fmt::format("{:x}", thread->GetThreadID());
+                val += ",";
             }
         }
         val.pop_back();
@@ -837,15 +791,11 @@ static void ReadRegister() {
     } else if (id == PSTATE_REGISTER) {
         IntToGdbHex(reply, static_cast<u32>(RegRead(id, current_thread)));
     } else if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
-        u128 r = FpuRead(id, current_thread);
-        LongToGdbHex(reply, r[0]);
-        LongToGdbHex(reply + 16, r[1]);
+        LongToGdbHex(reply, RegRead(id, current_thread));
     } else if (id == FPCR_REGISTER) {
-        u128 r = FpuRead(id, current_thread);
-        IntToGdbHex(reply, static_cast<u32>(r[0]));
-    } else if (id == FPCR_REGISTER + 1) {
-        u128 r = FpuRead(id, current_thread);
-        IntToGdbHex(reply, static_cast<u32>(r[0] >> 32));
+        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_998, current_thread));
+    } else {
+        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_997, current_thread));
     }
 
     SendReply(reinterpret_cast<char*>(reply));
@@ -872,18 +822,13 @@ static void ReadRegisters() {
 
     bufptr += 8;
 
-    u128 r;
-
-    for (u32 reg = UC_ARM64_REG_Q0; reg < FPCR_REGISTER; reg++) {
-        r = FpuRead(reg, current_thread);
-        LongToGdbHex(bufptr + reg * 32, r[0]);
-        LongToGdbHex(bufptr + reg * 32 + 16, r[1]);
+    for (u32 reg = UC_ARM64_REG_Q0; reg <= UC_ARM64_REG_Q0 + 31; reg++) {
+        LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
     }
 
     bufptr += 32 * 32;
 
-    r = FpuRead(FPCR_REGISTER, current_thread);
-    IntToGdbHex(bufptr, static_cast<u32>(r[0]));
+    LongToGdbHex(bufptr, RegRead(TODO_DUMMY_REG_998, current_thread));
 
     bufptr += 8;
 
@@ -908,12 +853,14 @@ static void WriteRegister() {
     } else if (id == PSTATE_REGISTER) {
         RegWrite(id, GdbHexToInt(buffer_ptr), current_thread);
     } else if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
-        FpuWrite(id, GdbHexToU128(buffer_ptr), current_thread);
+        RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
     } else if (id == FPCR_REGISTER) {
-    } else if (id == FPCR_REGISTER + 1) {
+        RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr), current_thread);
+    } else {
+        RegWrite(TODO_DUMMY_REG_997, GdbHexToLong(buffer_ptr), current_thread);
     }
 
-    // Update ARM context, skipping scheduler - no running threads at this point
+    // Update Unicorn context skipping scheduler, no running threads at this point
     Core::System::GetInstance()
         .ArmInterface(current_core)
         .LoadContext(current_thread->GetContext());
@@ -938,13 +885,13 @@ static void WriteRegisters() {
         } else if (reg >= UC_ARM64_REG_Q0 && reg < FPCR_REGISTER) {
             RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
         } else if (reg == FPCR_REGISTER) {
-            RegWrite(FPCR_REGISTER, GdbHexToLong(buffer_ptr + i * 16), current_thread);
-        } else if (reg == FPCR_REGISTER + 1) {
-            RegWrite(FPCR_REGISTER, GdbHexToLong(buffer_ptr + i * 16), current_thread);
+            RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr + i * 16), current_thread);
+        } else {
+            UNIMPLEMENTED();
         }
     }
 
-    // Update ARM context, skipping scheduler - no running threads at this point
+    // Update Unicorn context skipping scheduler, no running threads at this point
     Core::System::GetInstance()
         .ArmInterface(current_core)
         .LoadContext(current_thread->GetContext());
@@ -970,6 +917,12 @@ static void ReadMemory() {
         SendReply("E01");
     }
 
+    const auto& vm_manager = Core::CurrentProcess()->VMManager();
+    if (addr < vm_manager.GetCodeRegionBaseAddress() ||
+        addr >= vm_manager.GetMapRegionEndAddress()) {
+        return SendReply("E00");
+    }
+
     if (!Memory::IsValidVirtualAddress(addr)) {
         return SendReply("E00");
     }
@@ -1014,7 +967,7 @@ void Break(bool is_memory_break) {
 static void Step() {
     if (command_length > 1) {
         RegWrite(PC_REGISTER, GdbHexToLong(command_buffer + 1), current_thread);
-        // Update ARM context, skipping scheduler - no running threads at this point
+        // Update Unicorn context skipping scheduler, no running threads at this point
         Core::System::GetInstance()
             .ArmInterface(current_core)
             .LoadContext(current_thread->GetContext());
@@ -1057,7 +1010,7 @@ static bool CommitBreakpoint(BreakpointType type, VAddr addr, u64 len) {
     breakpoint.addr = addr;
     breakpoint.len = len;
     Memory::ReadBlock(addr, breakpoint.inst.data(), breakpoint.inst.size());
-    static constexpr std::array<u8, 4> btrap{0x00, 0x7d, 0x20, 0xd4};
+    static constexpr std::array<u8, 4> btrap{{0x00, 0x7d, 0x20, 0xd4}};
     Memory::WriteBlock(addr, btrap.data(), btrap.size());
     Core::System::GetInstance().InvalidateCpuInstructionCaches();
     p.insert({addr, breakpoint});
@@ -1368,15 +1321,13 @@ void SetCpuStepFlag(bool is_step) {
 }
 
 void SendTrap(Kernel::Thread* thread, int trap) {
-    if (!send_trap) {
-        return;
+    if (send_trap) {
+        if (!halt_loop || current_thread == thread) {
+            current_thread = thread;
+            SendSignal(thread, trap);
+        }
+        halt_loop = true;
+        send_trap = false;
     }
-
-    if (!halt_loop || current_thread == thread) {
-        current_thread = thread;
-        SendSignal(thread, trap);
-    }
-    halt_loop = true;
-    send_trap = false;
 }
 }; // namespace GDBStub

src/core/hle/kernel/svc.cpp

@@ -671,8 +671,7 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         break;
     }
     default:
-        LOG_WARNING(Kernel_SVC, "(STUBBED) Unimplemented svcGetInfo id=0x{:016X}", info_id);
-        return ERR_INVALID_ENUM_VALUE;
+        UNIMPLEMENTED();
     }
 
     return RESULT_SUCCESS;

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

@@ -6,6 +6,8 @@
 #include <cinttypes>
 #include <cstring>
 #include <stack>
+#include "applets/applets.h"
+#include "applets/software_keyboard.h"
 #include "audio_core/audio_renderer.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
@@ -16,9 +18,6 @@
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
-#include "core/hle/service/am/applets/applets.h"
-#include "core/hle/service/am/applets/software_keyboard.h"
-#include "core/hle/service/am/applets/stub_applet.h"
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
@@ -483,15 +482,11 @@ void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext&
     rb.Push(RESULT_SUCCESS);
 
     if (Settings::values.use_docked_mode) {
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor));
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight));
     } else {
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor));
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight));
     }
 
     LOG_DEBUG(Service_AM, "called");
@@ -766,9 +761,8 @@ static std::shared_ptr<Applets::Applet> GetAppletFromId(AppletId id) {
     case AppletId::SoftwareKeyboard:
         return std::make_shared<Applets::SoftwareKeyboard>();
     default:
-        LOG_ERROR(Service_AM, "Unimplemented AppletId [{:08X}]! -- Falling back to stub!",
-                  static_cast<u32>(id));
-        return std::make_shared<Applets::StubApplet>();
+        UNREACHABLE_MSG("Unimplemented AppletId [{:08X}]!", static_cast<u32>(id));
+        return nullptr;
     }
 }
 

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

@@ -1,70 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string>
-
-#include "common/hex_util.h"
-#include "common/logging/log.h"
-#include "core/hle/result.h"
-#include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/stub_applet.h"
-
-namespace Service::AM::Applets {
-
-static void LogCurrentStorage(AppletDataBroker& broker, std::string prefix) {
-    std::unique_ptr<IStorage> storage = broker.PopNormalDataToApplet();
-    for (; storage != nullptr; storage = broker.PopNormalDataToApplet()) {
-        const auto data = storage->GetData();
-        LOG_INFO(Service_AM,
-                 "called (STUBBED), during {} recieved normal data with size={:08X}, data={}",
-                 prefix, data.size(), Common::HexVectorToString(data));
-    }
-
-    storage = broker.PopInteractiveDataToApplet();
-    for (; storage != nullptr; storage = broker.PopInteractiveDataToApplet()) {
-        const auto data = storage->GetData();
-        LOG_INFO(Service_AM,
-                 "called (STUBBED), during {} recieved interactive data with size={:08X}, data={}",
-                 prefix, data.size(), Common::HexVectorToString(data));
-    }
-}
-
-StubApplet::StubApplet() = default;
-
-StubApplet::~StubApplet() = default;
-
-void StubApplet::Initialize() {
-    LOG_WARNING(Service_AM, "called (STUBBED)");
-    Applet::Initialize();
-    LogCurrentStorage(broker, "Initialize");
-}
-
-bool StubApplet::TransactionComplete() const {
-    LOG_WARNING(Service_AM, "called (STUBBED)");
-    return true;
-}
-
-ResultCode StubApplet::GetStatus() const {
-    LOG_WARNING(Service_AM, "called (STUBBED)");
-    return RESULT_SUCCESS;
-}
-
-void StubApplet::ExecuteInteractive() {
-    LOG_WARNING(Service_AM, "called (STUBBED)");
-    LogCurrentStorage(broker, "ExecuteInteractive");
-
-    broker.PushNormalDataFromApplet(IStorage{std::vector<u8>(0x1000)});
-    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
-    broker.SignalStateChanged();
-}
-
-void StubApplet::Execute() {
-    LOG_WARNING(Service_AM, "called (STUBBED)");
-    LogCurrentStorage(broker, "Execute");
-
-    broker.PushNormalDataFromApplet(IStorage{std::vector<u8>(0x1000)});
-    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
-    broker.SignalStateChanged();
-}
-} // namespace Service::AM::Applets

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

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

src/core/hle/service/audio/audout_u.cpp

@@ -44,10 +44,8 @@ enum class AudioState : u32 {
 
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
-    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core, std::string&& device_name,
-              std::string&& unique_name)
-        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params),
-          device_name(std::move(device_name)) {
+    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core)
+        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params) {
 
         static const FunctionInfo functions[] = {
             {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
@@ -71,7 +69,7 @@ public:
             Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
 
         stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count,
-                                       std::move(unique_name), [=]() { buffer_event->Signal(); });
+                                       "IAudioOut", [=]() { buffer_event->Signal(); });
     }
 
 private:
@@ -179,7 +177,6 @@ private:
 
     AudioCore::AudioOut& audio_core;
     AudioCore::StreamPtr stream;
-    std::string device_name;
 
     AudoutParams audio_params{};
 
@@ -202,15 +199,7 @@ void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
 void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Audio, "called");
 
-    const auto device_name_data{ctx.ReadBuffer()};
-    std::string device_name;
-    if (device_name_data[0] != '\0') {
-        device_name.assign(device_name_data.begin(), device_name_data.end());
-    } else {
-        device_name.assign(DefaultDevice.begin(), DefaultDevice.end());
-    }
-    ctx.WriteBuffer(device_name);
-
+    ctx.WriteBuffer(DefaultDevice);
     IPC::RequestParser rp{ctx};
     auto params{rp.PopRaw<AudoutParams>()};
     if (params.channel_count <= 2) {
@@ -223,9 +212,10 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
         params.sample_rate = DefaultSampleRate;
     }
 
-    std::string unique_name{fmt::format("{}-{}", device_name, audio_out_interfaces.size())};
-    auto audio_out_interface = std::make_shared<IAudioOut>(
-        params, *audio_core, std::move(device_name), std::move(unique_name));
+    // TODO(bunnei): Support more than one IAudioOut interface. When we add this, ListAudioOutsImpl
+    // will likely need to be updated as well.
+    ASSERT_MSG(!audio_out_interface, "Unimplemented");
+    audio_out_interface = std::make_shared<IAudioOut>(params, *audio_core);
 
     IPC::ResponseBuilder rb{ctx, 6, 0, 1};
     rb.Push(RESULT_SUCCESS);
@@ -234,8 +224,6 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(AudioCore::Codec::PcmFormat::Int16));
     rb.Push<u32>(static_cast<u32>(AudioState::Stopped));
     rb.PushIpcInterface<Audio::IAudioOut>(audio_out_interface);
-
-    audio_out_interfaces.push_back(std::move(audio_out_interface));
 }
 
 AudOutU::AudOutU() : ServiceFramework("audout:u") {

src/core/hle/service/audio/audout_u.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <vector>
 #include "core/hle/service/service.h"
 
 namespace AudioCore {
@@ -25,7 +24,7 @@ public:
     ~AudOutU() override;
 
 private:
-    std::vector<std::shared_ptr<IAudioOut>> audio_out_interfaces;
+    std::shared_ptr<IAudioOut> audio_out_interface;
     std::unique_ptr<AudioCore::AudioOut> audio_core;
 
     void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);

src/core/hle/service/filesystem/filesystem.cpp

@@ -341,10 +341,6 @@ std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
     return registered_cache_union;
 }
 
-void ClearUnionContents() {
-    registered_cache_union = nullptr;
-}
-
 FileSys::RegisteredCache* GetSystemNANDContents() {
     LOG_TRACE(Service_FS, "Opening System NAND Contents");
 
@@ -395,7 +391,6 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
         bis_factory = nullptr;
         save_data_factory = nullptr;
         sdmc_factory = nullptr;
-        ClearUnionContents();
     }
 
     auto nand_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir),

src/core/hle/service/filesystem/filesystem.h

@@ -49,7 +49,6 @@ ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space)
 ResultVal<FileSys::VirtualDir> OpenSDMC();
 
 std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
-void ClearUnionContents();
 
 FileSys::RegisteredCache* GetSystemNANDContents();
 FileSys::RegisteredCache* GetUserNANDContents();

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

@@ -71,9 +71,8 @@ void Controller_DebugPad::OnUpdate(u8* data, std::size_t size) {
 
 void Controller_DebugPad::OnLoadInputDevices() {
     std::transform(Settings::values.debug_pad_buttons.begin(),
-                   Settings::values.debug_pad_buttons.begin() +
-                       Settings::NativeButton::NUM_BUTTONS_HID,
-                   buttons.begin(), Input::CreateDevice<Input::ButtonDevice>);
+                   Settings::values.debug_pad_buttons.end(), buttons.begin(),
+                   Input::CreateDevice<Input::ButtonDevice>);
     std::transform(Settings::values.debug_pad_analogs.begin(),
                    Settings::values.debug_pad_analogs.end(), analogs.begin(),
                    Input::CreateDevice<Input::AnalogDevice>);

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

@@ -5,8 +5,6 @@
 #include <cstring>
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core_timing.h"
-#include "core/core_timing_util.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"
 
 namespace Service::Nvidia::Devices {
@@ -35,8 +33,6 @@ u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vec
         return ZBCQueryTable(input, output);
     case IoctlCommand::IocFlushL2:
         return FlushL2(input, output);
-    case IoctlCommand::IocGetGpuTime:
-        return GetGpuTime(input, output);
     }
     UNIMPLEMENTED_MSG("Unimplemented ioctl");
     return 0;
@@ -173,13 +169,4 @@ u32 nvhost_ctrl_gpu::FlushL2(const std::vector<u8>& input, std::vector<u8>& outp
     return 0;
 }
 
-u32 nvhost_ctrl_gpu::GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called");
-    IoctlGetGpuTime params{};
-    std::memcpy(&params, input.data(), input.size());
-    params.gpu_time = CoreTiming::cyclesToNs(CoreTiming::GetTicks());
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
 } // namespace Service::Nvidia::Devices

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

@@ -156,11 +156,6 @@ private:
     };
     static_assert(sizeof(IoctlFlushL2) == 8, "IoctlFlushL2 is incorrect size");
 
-    struct IoctlGetGpuTime {
-        u64_le gpu_time;
-    };
-    static_assert(sizeof(IoctlGetGpuTime) == 8, "IoctlGetGpuTime is incorrect size");
-
     u32 GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output);
     u32 GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output);
     u32 GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output);
@@ -169,7 +164,6 @@ private:
     u32 ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output);
     u32 ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>& output);
     u32 FlushL2(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/interface.cpp

@@ -88,20 +88,6 @@ void NVDRV::FinishInitialize(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void NVDRV::GetStatus(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void NVDRV::DumpGraphicsMemoryInfo(Kernel::HLERequestContext& ctx) {
-    // According to SwitchBrew, this has no inputs and no outputs, so effectively does nothing on
-    // retail hardware.
-    LOG_DEBUG(Service_NVDRV, "called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
     : ServiceFramework(name), nvdrv(std::move(nvdrv)) {
     static const FunctionInfo functions[] = {
@@ -111,10 +97,10 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
         {3, &NVDRV::Initialize, "Initialize"},
         {4, &NVDRV::QueryEvent, "QueryEvent"},
         {5, nullptr, "MapSharedMem"},
-        {6, &NVDRV::GetStatus, "GetStatus"},
+        {6, nullptr, "GetStatus"},
         {7, nullptr, "ForceSetClientPID"},
         {8, &NVDRV::SetClientPID, "SetClientPID"},
-        {9, &NVDRV::DumpGraphicsMemoryInfo, "DumpGraphicsMemoryInfo"},
+        {9, nullptr, "DumpGraphicsMemoryInfo"},
         {10, nullptr, "InitializeDevtools"},
         {11, &NVDRV::Ioctl, "Ioctl2"},
         {12, nullptr, "Ioctl3"},

src/core/hle/service/nvdrv/interface.h

@@ -24,8 +24,6 @@ private:
     void QueryEvent(Kernel::HLERequestContext& ctx);
     void SetClientPID(Kernel::HLERequestContext& ctx);
     void FinishInitialize(Kernel::HLERequestContext& ctx);
-    void GetStatus(Kernel::HLERequestContext& ctx);
-    void DumpGraphicsMemoryInfo(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<Module> nvdrv;
 

src/core/hle/service/sm/sm.cpp

@@ -63,17 +63,6 @@ ResultVal<Kernel::SharedPtr<Kernel::ServerPort>> ServiceManager::RegisterService
     return MakeResult<Kernel::SharedPtr<Kernel::ServerPort>>(std::move(server_port));
 }
 
-ResultCode ServiceManager::UnregisterService(const std::string& name) {
-    CASCADE_CODE(ValidateServiceName(name));
-
-    const auto iter = registered_services.find(name);
-    if (iter == registered_services.end())
-        return ERR_SERVICE_NOT_REGISTERED;
-
-    registered_services.erase(iter);
-    return RESULT_SUCCESS;
-}
-
 ResultVal<Kernel::SharedPtr<Kernel::ClientPort>> ServiceManager::GetServicePort(
     const std::string& name) {
 
@@ -138,52 +127,13 @@ void SM::GetService(Kernel::HLERequestContext& ctx) {
     }
 }
 
-void SM::RegisterService(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    const auto name_buf = rp.PopRaw<std::array<char, 8>>();
-    const auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
-
-    const std::string name(name_buf.begin(), end);
-
-    const auto unk_bool = static_cast<bool>(rp.PopRaw<u32>());
-    const auto session_count = rp.PopRaw<u32>();
-
-    LOG_DEBUG(Service_SM, "called with unk_bool={}", unk_bool);
-
-    auto handle = service_manager->RegisterService(name, session_count);
-    if (handle.Failed()) {
-        LOG_ERROR(Service_SM, "failed to register service with error_code={:08X}",
-                  handle.Code().raw);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(handle.Code());
-        return;
-    }
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
-    rb.Push(handle.Code());
-    rb.PushMoveObjects(std::move(handle).Unwrap());
-}
-
-void SM::UnregisterService(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    const auto name_buf = rp.PopRaw<std::array<char, 8>>();
-    const auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
-
-    const std::string name(name_buf.begin(), end);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(service_manager->UnregisterService(name));
-}
-
 SM::SM(std::shared_ptr<ServiceManager> service_manager)
     : ServiceFramework("sm:", 4), service_manager(std::move(service_manager)) {
     static const FunctionInfo functions[] = {
         {0x00000000, &SM::Initialize, "Initialize"},
         {0x00000001, &SM::GetService, "GetService"},
-        {0x00000002, &SM::RegisterService, "RegisterService"},
-        {0x00000003, &SM::UnregisterService, "UnregisterService"},
+        {0x00000002, nullptr, "RegisterService"},
+        {0x00000003, nullptr, "UnregisterService"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/sm/sm.h

@@ -35,8 +35,6 @@ public:
 private:
     void Initialize(Kernel::HLERequestContext& ctx);
     void GetService(Kernel::HLERequestContext& ctx);
-    void RegisterService(Kernel::HLERequestContext& ctx);
-    void UnregisterService(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<ServiceManager> service_manager;
 };
@@ -50,7 +48,6 @@ public:
 
     ResultVal<Kernel::SharedPtr<Kernel::ServerPort>> RegisterService(std::string name,
                                                                      unsigned int max_sessions);
-    ResultCode UnregisterService(const std::string& name);
     ResultVal<Kernel::SharedPtr<Kernel::ClientPort>> GetServicePort(const std::string& name);
     ResultVal<Kernel::SharedPtr<Kernel::ClientSession>> ConnectToService(const std::string& name);
 

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

@@ -510,11 +510,7 @@ private:
 
         if (transaction == TransactionId::Connect) {
             IGBPConnectRequestParcel request{ctx.ReadBuffer()};
-            IGBPConnectResponseParcel response{
-                static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedWidth) *
-                                 Settings::values.resolution_factor),
-                static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedHeight) *
-                                 Settings::values.resolution_factor)};
+            IGBPConnectResponseParcel response{1280, 720};
             ctx.WriteBuffer(response.Serialize());
         } else if (transaction == TransactionId::SetPreallocatedBuffer) {
             IGBPSetPreallocatedBufferRequestParcel request{ctx.ReadBuffer()};
@@ -696,15 +692,11 @@ private:
         rb.Push(RESULT_SUCCESS);
 
         if (Settings::values.use_docked_mode) {
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor));
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight));
         } else {
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor));
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight));
         }
 
         rb.PushRaw<float>(60.0f);
@@ -909,15 +901,11 @@ private:
         rb.Push(RESULT_SUCCESS);
 
         if (Settings::values.use_docked_mode) {
-            rb.Push(static_cast<u64>(DisplayResolution::DockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor));
-            rb.Push(static_cast<u64>(DisplayResolution::DockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u64>(DisplayResolution::DockedWidth));
+            rb.Push(static_cast<u64>(DisplayResolution::DockedHeight));
         } else {
-            rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor));
-            rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth));
+            rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight));
         }
     }
 
@@ -934,8 +922,6 @@ private:
     void ListDisplays(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         DisplayInfo display_info;
-        display_info.width *= static_cast<u64>(Settings::values.resolution_factor);
-        display_info.height *= static_cast<u64>(Settings::values.resolution_factor);
         ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);

src/core/settings.h

@@ -403,7 +403,6 @@ struct Values {
     bool use_gdbstub;
     u16 gdbstub_port;
     std::string program_args;
-    bool dump_exefs;
     bool dump_nso;
 
     // WebService

src/video_core/CMakeLists.txt

@@ -21,8 +21,6 @@ add_library(video_core STATIC
     macro_interpreter.h
     memory_manager.cpp
     memory_manager.h
-    morton.cpp
-    morton.h
     rasterizer_cache.cpp
     rasterizer_cache.h
     rasterizer_interface.h
@@ -30,8 +28,6 @@ add_library(video_core STATIC
     renderer_base.h
     renderer_opengl/gl_buffer_cache.cpp
     renderer_opengl/gl_buffer_cache.h
-    renderer_opengl/gl_global_cache.cpp
-    renderer_opengl/gl_global_cache.h
     renderer_opengl/gl_primitive_assembler.cpp
     renderer_opengl/gl_primitive_assembler.h
     renderer_opengl/gl_rasterizer.cpp
@@ -66,6 +62,7 @@ add_library(video_core STATIC
     textures/decoders.cpp
     textures/decoders.h
     textures/texture.h
+    utils.h
     video_core.cpp
     video_core.h
 )

src/video_core/engines/maxwell_3d.cpp

@@ -319,11 +319,6 @@ void Maxwell3D::DrawArrays() {
     }
 }
 
-bool operator<(const Maxwell3D::GlobalMemoryDescriptor& lhs,
-               const Maxwell3D::GlobalMemoryDescriptor& rhs) {
-    return std::tie(lhs.cbuf_index, lhs.cbuf_offset) < std::tie(rhs.cbuf_index, rhs.cbuf_offset);
-}
-
 void Maxwell3D::ProcessCBBind(Regs::ShaderStage stage) {
     // Bind the buffer currently in CB_ADDRESS to the specified index in the desired shader stage.
     auto& shader = state.shader_stages[static_cast<std::size_t>(stage)];

src/video_core/engines/maxwell_3d.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <array>
-#include <set>
 #include <unordered_map>
 #include <vector>
 #include "common/assert.h"
@@ -32,12 +31,6 @@ public:
     explicit Maxwell3D(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager);
     ~Maxwell3D() = default;
 
-    /// Structure representing a global memory region
-    struct GlobalMemoryDescriptor {
-        u64 cbuf_index;
-        u64 cbuf_offset;
-    };
-
     /// Register structure of the Maxwell3D engine.
     /// TODO(Subv): This structure will need to be made bigger as more registers are discovered.
     struct Regs {
@@ -396,13 +389,6 @@ public:
                 ReverseSubtract = 3,
                 Min = 4,
                 Max = 5,
-
-                // These values are used by Nouveau and some games.
-                AddGL = 0x8006,
-                SubtractGL = 0x8007,
-                ReverseSubtractGL = 0x8008,
-                MinGL = 0x800a,
-                MaxGL = 0x800b
             };
 
             enum class Factor : u32 {
@@ -742,7 +728,20 @@ public:
 
                 u32 vb_element_base;
 
-                INSERT_PADDING_WORDS(0x38);
+                INSERT_PADDING_WORDS(0x36);
+
+                union {
+                    BitField<0, 1, u32> c0;
+                    BitField<1, 1, u32> c1;
+                    BitField<2, 1, u32> c2;
+                    BitField<3, 1, u32> c3;
+                    BitField<4, 1, u32> c4;
+                    BitField<5, 1, u32> c5;
+                    BitField<6, 1, u32> c6;
+                    BitField<7, 1, u32> c7;
+                } clip_distance_enabled;
+
+                INSERT_PADDING_WORDS(0x1);
 
                 float point_size;
 
@@ -886,7 +885,32 @@ public:
 
                 Cull cull;
 
-                INSERT_PADDING_WORDS(0x28);
+                u32 pixel_center_integer;
+
+                INSERT_PADDING_WORDS(0x1);
+
+                u32 viewport_transform_enabled;
+
+                INSERT_PADDING_WORDS(0x3);
+
+                union {
+                    BitField<0, 1, u32> depth_range_0_1;
+                    BitField<3, 1, u32> depth_clamp_near;
+                    BitField<4, 1, u32> depth_clamp_far;
+                } view_volume_clip_control;
+
+                union {
+                    BitField<0, 4, u32> c0;
+                    BitField<4, 4, u32> c1;
+                    BitField<8, 4, u32> c2;
+                    BitField<12, 4, u32> c3;
+                    BitField<16, 4, u32> c4;
+                    BitField<20, 4, u32> c5;
+                    BitField<24, 4, u32> c6;
+                    BitField<28, 4, u32> c7;
+                } clip_distance_mode;
+
+                INSERT_PADDING_WORDS(0x20);
 
                 struct {
                     u32 enable;
@@ -1044,8 +1068,6 @@ public:
 
         std::array<ShaderStageInfo, Regs::MaxShaderStage> shader_stages;
         u32 current_instance = 0; ///< Current instance to be used to simulate instanced rendering.
-
-        std::set<GlobalMemoryDescriptor> global_memory_uniforms;
     };
 
     State state{};
@@ -1078,9 +1100,6 @@ public:
         return macro_memory;
     }
 
-    std::string CreateGlobalMemoryRegion(std::tuple<u64, u64, u64> iadd_data);
-    std::set<std::pair<u64, u64>> ListGlobalMemoryRegions() const;
-
 private:
     void InitializeRegisterDefaults();
 
@@ -1135,9 +1154,6 @@ private:
     void DrawArrays();
 };
 
-bool operator<(const Maxwell3D::GlobalMemoryDescriptor& lhs,
-               const Maxwell3D::GlobalMemoryDescriptor& rhs);
-
 #define ASSERT_REG_POSITION(field_name, position)                                                  \
     static_assert(offsetof(Maxwell3D::Regs, field_name) == position * 4,                           \
                   "Field " #field_name " has invalid position")
@@ -1185,6 +1201,7 @@ ASSERT_REG_POSITION(stencil_front_mask, 0x4E7);
 ASSERT_REG_POSITION(frag_color_clamp, 0x4EA);
 ASSERT_REG_POSITION(screen_y_control, 0x4EB);
 ASSERT_REG_POSITION(vb_element_base, 0x50D);
+ASSERT_REG_POSITION(clip_distance_enabled, 0x544);
 ASSERT_REG_POSITION(point_size, 0x546);
 ASSERT_REG_POSITION(zeta_enable, 0x54E);
 ASSERT_REG_POSITION(multisample_control, 0x54F);
@@ -1203,6 +1220,9 @@ ASSERT_REG_POSITION(primitive_restart, 0x591);
 ASSERT_REG_POSITION(index_array, 0x5F2);
 ASSERT_REG_POSITION(instanced_arrays, 0x620);
 ASSERT_REG_POSITION(cull, 0x646);
+ASSERT_REG_POSITION(pixel_center_integer, 0x649);
+ASSERT_REG_POSITION(viewport_transform_enabled, 0x64B);
+ASSERT_REG_POSITION(clip_distance_mode, 0x650);
 ASSERT_REG_POSITION(logic_op, 0x671);
 ASSERT_REG_POSITION(clear_buffers, 0x674);
 ASSERT_REG_POSITION(color_mask, 0x680);

src/video_core/engines/shader_bytecode.h

@@ -1,4 +1,4 @@
-// Copyright 2018 yuzu Emulator Project
+// Copyright 2018 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
@@ -82,8 +82,6 @@ union Attribute {
         Position = 7,
         Attribute_0 = 8,
         Attribute_31 = 39,
-        ClipDistances0123 = 44,
-        ClipDistances4567 = 45,
         PointCoord = 46,
         // This attribute contains a tuple of (~, ~, InstanceId, VertexId) when inside a vertex
         // shader, and a tuple of (TessCoord.x, TessCoord.y, TessCoord.z, ~) when inside a Tess Eval
@@ -155,7 +153,6 @@ enum class PredCondition : u64 {
     NotEqual = 5,
     GreaterEqual = 6,
     LessThanWithNan = 9,
-    LessEqualWithNan = 11,
     GreaterThanWithNan = 12,
     NotEqualWithNan = 13,
     GreaterEqualWithNan = 14,
@@ -208,8 +205,6 @@ enum class UniformType : u64 {
     SignedShort = 3,
     Single = 4,
     Double = 5,
-    Quad = 6,
-    UnsignedQuad = 7,
 };
 
 enum class StoreType : u64 {
@@ -266,7 +261,7 @@ enum class FlowCondition : u64 {
     Fcsm_Tr = 0x1C, // TODO(bunnei): What is this used for?
 };
 
-enum class ConditionCode : u64 {
+enum class ControlCode : u64 {
     F = 0,
     LT = 1,
     EQ = 2,
@@ -370,11 +365,6 @@ enum class HalfPrecision : u64 {
     FMZ = 2,
 };
 
-enum class R2pMode : u64 {
-    Pr = 0,
-    Cc = 1,
-};
-
 enum class IpaInterpMode : u64 {
     Linear = 0,
     Perspective = 1,
@@ -579,6 +569,7 @@ union Instruction {
         BitField<39, 2, u64> tab5cb8_2;
         BitField<41, 3, u64> tab5c68_1;
         BitField<44, 2, u64> tab5c68_0;
+        BitField<47, 1, u64> cc;
         BitField<48, 1, u64> negate_b;
     } fmul;
 
@@ -781,12 +772,6 @@ union Instruction {
         BitField<44, 2, u64> unknown;
     } st_l;
 
-    union {
-        BitField<48, 3, UniformType> type;
-        BitField<46, 2, u64> cache_mode;
-        BitField<20, 24, s64> offset_immediate;
-    } ld_g;
-
     union {
         BitField<0, 3, u64> pred0;
         BitField<3, 3, u64> pred3;
@@ -846,7 +831,7 @@ union Instruction {
     union {
         BitField<0, 3, u64> pred0;
         BitField<3, 3, u64> pred3;
-        BitField<8, 5, ConditionCode> cc; // flag in cc
+        BitField<8, 5, ControlCode> cc; // flag in cc
         BitField<39, 3, u64> pred39;
         BitField<42, 1, u64> neg_pred39;
         BitField<45, 4, PredOperation> op; // op with pred39
@@ -869,12 +854,6 @@ union Instruction {
         BitField<39, 3, u64> pred39;
     } hsetp2;
 
-    union {
-        BitField<40, 1, R2pMode> mode;
-        BitField<41, 2, u64> byte;
-        BitField<20, 7, u64> immediate_mask;
-    } r2p;
-
     union {
         BitField<39, 3, u64> pred39;
         BitField<42, 1, u64> neg_pred;
@@ -1256,7 +1235,7 @@ union Instruction {
     BitField<60, 1, u64> is_b_gpr;
     BitField<59, 1, u64> is_c_gpr;
     BitField<20, 24, s64> smem_imm;
-    BitField<0, 5, ConditionCode> flow_condition_code;
+    BitField<0, 5, ControlCode> flow_control_code;
 
     Attribute attribute;
     Sampler sampler;
@@ -1277,7 +1256,6 @@ public:
         BFE_C,
         BFE_R,
         BFE_IMM,
-        BFI_IMM_R,
         BRA,
         PBK,
         LD_A,
@@ -1403,7 +1381,6 @@ public:
         PSETP,
         PSET,
         CSETP,
-        R2P_IMM,
         XMAD_IMM,
         XMAD_CR,
         XMAD_RC,
@@ -1419,7 +1396,6 @@ public:
         ArithmeticHalf,
         ArithmeticHalfImmediate,
         Bfe,
-        Bfi,
         Shift,
         Ffma,
         Hfma2,
@@ -1434,7 +1410,6 @@ public:
         HalfSetPredicate,
         PredicateSetPredicate,
         PredicateSetRegister,
-        RegisterSetPredicate,
         Conversion,
         Xmad,
         Unknown,
@@ -1638,7 +1613,6 @@ private:
             INST("0100110000000---", Id::BFE_C, Type::Bfe, "BFE_C"),
             INST("0101110000000---", Id::BFE_R, Type::Bfe, "BFE_R"),
             INST("0011100-00000---", Id::BFE_IMM, Type::Bfe, "BFE_IMM"),
-            INST("0011011-11110---", Id::BFI_IMM_R, Type::Bfi, "BFI_IMM_R"),
             INST("0100110001000---", Id::LOP_C, Type::ArithmeticInteger, "LOP_C"),
             INST("0101110001000---", Id::LOP_R, Type::ArithmeticInteger, "LOP_R"),
             INST("0011100001000---", Id::LOP_IMM, Type::ArithmeticInteger, "LOP_IMM"),
@@ -1673,7 +1647,6 @@ private:
             INST("0101000010001---", Id::PSET, Type::PredicateSetRegister, "PSET"),
             INST("0101000010010---", Id::PSETP, Type::PredicateSetPredicate, "PSETP"),
             INST("010100001010----", Id::CSETP, Type::PredicateSetPredicate, "CSETP"),
-            INST("0011100-11110---", Id::R2P_IMM, Type::RegisterSetPredicate, "R2P_IMM"),
             INST("0011011-00------", Id::XMAD_IMM, Type::Xmad, "XMAD_IMM"),
             INST("0100111---------", Id::XMAD_CR, Type::Xmad, "XMAD_CR"),
             INST("010100010-------", Id::XMAD_RC, Type::Xmad, "XMAD_RC"),

src/video_core/engines/shader_header.h

@@ -62,16 +62,7 @@ struct Header {
             INSERT_PADDING_BYTES(1);  // ImapSystemValuesB
             INSERT_PADDING_BYTES(16); // ImapGenericVector[32]
             INSERT_PADDING_BYTES(2);  // ImapColor
-            union {
-                BitField<0, 8, u16> clip_distances;
-                BitField<8, 1, u16> point_sprite_s;
-                BitField<9, 1, u16> point_sprite_t;
-                BitField<10, 1, u16> fog_coordinate;
-                BitField<12, 1, u16> tessellation_eval_point_u;
-                BitField<13, 1, u16> tessellation_eval_point_v;
-                BitField<14, 1, u16> instance_id;
-                BitField<15, 1, u16> vertex_id;
-            };
+            INSERT_PADDING_BYTES(2);  // ImapSystemValuesC
             INSERT_PADDING_BYTES(5);  // ImapFixedFncTexture[10]
             INSERT_PADDING_BYTES(1);  // ImapReserved
             INSERT_PADDING_BYTES(3);  // OmapSystemValuesA

src/video_core/macro_interpreter.cpp

@@ -35,7 +35,6 @@ void MacroInterpreter::Reset() {
     // The next parameter index starts at 1, because $r1 already has the value of the first
     // parameter.
     next_parameter_index = 1;
-    carry_flag = false;
 }
 
 bool MacroInterpreter::Step(u32 offset, bool is_delay_slot) {
@@ -136,28 +135,14 @@ MacroInterpreter::Opcode MacroInterpreter::GetOpcode(u32 offset) const {
     return {macro_memory[offset + pc / sizeof(u32)]};
 }
 
-u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) {
+u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const {
     switch (operation) {
-    case ALUOperation::Add: {
-        const u64 result{static_cast<u64>(src_a) + src_b};
-        carry_flag = result > 0xffffffff;
-        return static_cast<u32>(result);
-    }
-    case ALUOperation::AddWithCarry: {
-        const u64 result{static_cast<u64>(src_a) + src_b + (carry_flag ? 1ULL : 0ULL)};
-        carry_flag = result > 0xffffffff;
-        return static_cast<u32>(result);
-    }
-    case ALUOperation::Subtract: {
-        const u64 result{static_cast<u64>(src_a) - src_b};
-        carry_flag = result < 0x100000000;
-        return static_cast<u32>(result);
-    }
-    case ALUOperation::SubtractWithBorrow: {
-        const u64 result{static_cast<u64>(src_a) - src_b - (carry_flag ? 0ULL : 1ULL)};
-        carry_flag = result < 0x100000000;
-        return static_cast<u32>(result);
-    }
+    case ALUOperation::Add:
+        return src_a + src_b;
+    // TODO(Subv): Implement AddWithCarry
+    case ALUOperation::Subtract:
+        return src_a - src_b;
+    // TODO(Subv): Implement SubtractWithBorrow
     case ALUOperation::Xor:
         return src_a ^ src_b;
     case ALUOperation::Or:

src/video_core/macro_interpreter.h

@@ -117,7 +117,7 @@ private:
     bool Step(u32 offset, bool is_delay_slot);
 
     /// Calculates the result of an ALU operation. src_a OP src_b;
-    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b);
+    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const;
 
     /// Performs the result operation on the input result and stores it in the specified register
     /// (if necessary).
@@ -165,7 +165,5 @@ private:
     std::vector<u32> parameters;
     /// Index of the next parameter that will be fetched by the 'parm' instruction.
     u32 next_parameter_index = 0;
-
-    bool carry_flag{};
 };
 } // namespace Tegra

src/video_core/memory_manager.cpp

@@ -9,13 +9,6 @@
 
 namespace Tegra {
 
-MemoryManager::MemoryManager() {
-    // Mark the first page as reserved, so that 0 is not a valid GPUVAddr. Otherwise, games might
-    // try to use 0 as a valid address, which is also used to mean nullptr. This fixes a bug with
-    // Undertale using 0 for a render target.
-    PageSlot(0) = static_cast<u64>(PageStatus::Reserved);
-}
-
 GPUVAddr MemoryManager::AllocateSpace(u64 size, u64 align) {
     const std::optional<GPUVAddr> gpu_addr{FindFreeBlock(0, size, align, PageStatus::Unmapped)};
 

src/video_core/memory_manager.h

@@ -18,7 +18,7 @@ using GPUVAddr = u64;
 
 class MemoryManager final {
 public:
-    MemoryManager();
+    MemoryManager() = default;
 
     GPUVAddr AllocateSpace(u64 size, u64 align);
     GPUVAddr AllocateSpace(GPUVAddr gpu_addr, u64 size, u64 align);
@@ -37,7 +37,6 @@ private:
     enum class PageStatus : u64 {
         Unmapped = 0xFFFFFFFFFFFFFFFFULL,
         Allocated = 0xFFFFFFFFFFFFFFFEULL,
-        Reserved = 0xFFFFFFFFFFFFFFFDULL,
     };
 
     std::optional<GPUVAddr> FindFreeBlock(GPUVAddr region_start, u64 size, u64 align,

src/video_core/morton.cpp

@@ -1,353 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <array>
-#include <cstring>
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "core/memory.h"
-#include "video_core/morton.h"
-#include "video_core/surface.h"
-#include "video_core/textures/decoders.h"
-
-namespace VideoCore {
-
-using Surface::GetBytesPerPixel;
-using Surface::PixelFormat;
-
-using MortonCopyFn = void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr);
-using ConversionArray = std::array<MortonCopyFn, Surface::MaxPixelFormat>;
-
-template <bool morton_to_linear, PixelFormat format>
-static void MortonCopy(u32 stride, u32 block_height, u32 height, u32 block_depth, u32 depth,
-                       u8* buffer, std::size_t buffer_size, VAddr addr) {
-    constexpr u32 bytes_per_pixel = GetBytesPerPixel(format);
-
-    // With the BCn formats (DXT and DXN), each 4x4 tile is swizzled instead of just individual
-    // pixel values.
-    const u32 tile_size_x{GetDefaultBlockWidth(format)};
-    const u32 tile_size_y{GetDefaultBlockHeight(format)};
-
-    if constexpr (morton_to_linear) {
-        Tegra::Texture::UnswizzleTexture(buffer, addr, tile_size_x, tile_size_y, bytes_per_pixel,
-                                         stride, height, depth, block_height, block_depth);
-    } else {
-        Tegra::Texture::CopySwizzledData((stride + tile_size_x - 1) / tile_size_x,
-                                         (height + tile_size_y - 1) / tile_size_y, depth,
-                                         bytes_per_pixel, bytes_per_pixel, Memory::GetPointer(addr),
-                                         buffer, false, block_height, block_depth);
-    }
-}
-
-static constexpr ConversionArray morton_to_linear_fns = {
-    // clang-format off
-        MortonCopy<true, PixelFormat::ABGR8U>,
-        MortonCopy<true, PixelFormat::ABGR8S>,
-        MortonCopy<true, PixelFormat::ABGR8UI>,
-        MortonCopy<true, PixelFormat::B5G6R5U>,
-        MortonCopy<true, PixelFormat::A2B10G10R10U>,
-        MortonCopy<true, PixelFormat::A1B5G5R5U>,
-        MortonCopy<true, PixelFormat::R8U>,
-        MortonCopy<true, PixelFormat::R8UI>,
-        MortonCopy<true, PixelFormat::RGBA16F>,
-        MortonCopy<true, PixelFormat::RGBA16U>,
-        MortonCopy<true, PixelFormat::RGBA16UI>,
-        MortonCopy<true, PixelFormat::R11FG11FB10F>,
-        MortonCopy<true, PixelFormat::RGBA32UI>,
-        MortonCopy<true, PixelFormat::DXT1>,
-        MortonCopy<true, PixelFormat::DXT23>,
-        MortonCopy<true, PixelFormat::DXT45>,
-        MortonCopy<true, PixelFormat::DXN1>,
-        MortonCopy<true, PixelFormat::DXN2UNORM>,
-        MortonCopy<true, PixelFormat::DXN2SNORM>,
-        MortonCopy<true, PixelFormat::BC7U>,
-        MortonCopy<true, PixelFormat::BC6H_UF16>,
-        MortonCopy<true, PixelFormat::BC6H_SF16>,
-        MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
-        MortonCopy<true, PixelFormat::G8R8U>,
-        MortonCopy<true, PixelFormat::G8R8S>,
-        MortonCopy<true, PixelFormat::BGRA8>,
-        MortonCopy<true, PixelFormat::RGBA32F>,
-        MortonCopy<true, PixelFormat::RG32F>,
-        MortonCopy<true, PixelFormat::R32F>,
-        MortonCopy<true, PixelFormat::R16F>,
-        MortonCopy<true, PixelFormat::R16U>,
-        MortonCopy<true, PixelFormat::R16S>,
-        MortonCopy<true, PixelFormat::R16UI>,
-        MortonCopy<true, PixelFormat::R16I>,
-        MortonCopy<true, PixelFormat::RG16>,
-        MortonCopy<true, PixelFormat::RG16F>,
-        MortonCopy<true, PixelFormat::RG16UI>,
-        MortonCopy<true, PixelFormat::RG16I>,
-        MortonCopy<true, PixelFormat::RG16S>,
-        MortonCopy<true, PixelFormat::RGB32F>,
-        MortonCopy<true, PixelFormat::RGBA8_SRGB>,
-        MortonCopy<true, PixelFormat::RG8U>,
-        MortonCopy<true, PixelFormat::RG8S>,
-        MortonCopy<true, PixelFormat::RG32UI>,
-        MortonCopy<true, PixelFormat::R32UI>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X8>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X5>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X4>,
-        MortonCopy<true, PixelFormat::BGRA8_SRGB>,
-        MortonCopy<true, PixelFormat::DXT1_SRGB>,
-        MortonCopy<true, PixelFormat::DXT23_SRGB>,
-        MortonCopy<true, PixelFormat::DXT45_SRGB>,
-        MortonCopy<true, PixelFormat::BC7U_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_4X4_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X8_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X5_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X4_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X5>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X5_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_10X8>,
-        MortonCopy<true, PixelFormat::ASTC_2D_10X8_SRGB>,
-        MortonCopy<true, PixelFormat::Z32F>,
-        MortonCopy<true, PixelFormat::Z16>,
-        MortonCopy<true, PixelFormat::Z24S8>,
-        MortonCopy<true, PixelFormat::S8Z24>,
-        MortonCopy<true, PixelFormat::Z32FS8>,
-    // clang-format on
-};
-
-static constexpr ConversionArray linear_to_morton_fns = {
-    // clang-format off
-        MortonCopy<false, PixelFormat::ABGR8U>,
-        MortonCopy<false, PixelFormat::ABGR8S>,
-        MortonCopy<false, PixelFormat::ABGR8UI>,
-        MortonCopy<false, PixelFormat::B5G6R5U>,
-        MortonCopy<false, PixelFormat::A2B10G10R10U>,
-        MortonCopy<false, PixelFormat::A1B5G5R5U>,
-        MortonCopy<false, PixelFormat::R8U>,
-        MortonCopy<false, PixelFormat::R8UI>,
-        MortonCopy<false, PixelFormat::RGBA16F>,
-        MortonCopy<false, PixelFormat::RGBA16U>,
-        MortonCopy<false, PixelFormat::RGBA16UI>,
-        MortonCopy<false, PixelFormat::R11FG11FB10F>,
-        MortonCopy<false, PixelFormat::RGBA32UI>,
-        MortonCopy<false, PixelFormat::DXT1>,
-        MortonCopy<false, PixelFormat::DXT23>,
-        MortonCopy<false, PixelFormat::DXT45>,
-        MortonCopy<false, PixelFormat::DXN1>,
-        MortonCopy<false, PixelFormat::DXN2UNORM>,
-        MortonCopy<false, PixelFormat::DXN2SNORM>,
-        MortonCopy<false, PixelFormat::BC7U>,
-        MortonCopy<false, PixelFormat::BC6H_UF16>,
-        MortonCopy<false, PixelFormat::BC6H_SF16>,
-        // TODO(Subv): Swizzling ASTC formats are not supported
-        nullptr,
-        MortonCopy<false, PixelFormat::G8R8U>,
-        MortonCopy<false, PixelFormat::G8R8S>,
-        MortonCopy<false, PixelFormat::BGRA8>,
-        MortonCopy<false, PixelFormat::RGBA32F>,
-        MortonCopy<false, PixelFormat::RG32F>,
-        MortonCopy<false, PixelFormat::R32F>,
-        MortonCopy<false, PixelFormat::R16F>,
-        MortonCopy<false, PixelFormat::R16U>,
-        MortonCopy<false, PixelFormat::R16S>,
-        MortonCopy<false, PixelFormat::R16UI>,
-        MortonCopy<false, PixelFormat::R16I>,
-        MortonCopy<false, PixelFormat::RG16>,
-        MortonCopy<false, PixelFormat::RG16F>,
-        MortonCopy<false, PixelFormat::RG16UI>,
-        MortonCopy<false, PixelFormat::RG16I>,
-        MortonCopy<false, PixelFormat::RG16S>,
-        MortonCopy<false, PixelFormat::RGB32F>,
-        MortonCopy<false, PixelFormat::RGBA8_SRGB>,
-        MortonCopy<false, PixelFormat::RG8U>,
-        MortonCopy<false, PixelFormat::RG8S>,
-        MortonCopy<false, PixelFormat::RG32UI>,
-        MortonCopy<false, PixelFormat::R32UI>,
-        nullptr,
-        nullptr,
-        nullptr,
-        MortonCopy<false, PixelFormat::BGRA8_SRGB>,
-        MortonCopy<false, PixelFormat::DXT1_SRGB>,
-        MortonCopy<false, PixelFormat::DXT23_SRGB>,
-        MortonCopy<false, PixelFormat::DXT45_SRGB>,
-        MortonCopy<false, PixelFormat::BC7U_SRGB>,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        MortonCopy<false, PixelFormat::Z32F>,
-        MortonCopy<false, PixelFormat::Z16>,
-        MortonCopy<false, PixelFormat::Z24S8>,
-        MortonCopy<false, PixelFormat::S8Z24>,
-        MortonCopy<false, PixelFormat::Z32FS8>,
-    // clang-format on
-};
-
-constexpr MortonCopyFn GetSwizzleFunction(MortonSwizzleMode mode, Surface::PixelFormat format) {
-    switch (mode) {
-    case MortonSwizzleMode::MortonToLinear:
-        return morton_to_linear_fns[static_cast<std::size_t>(format)];
-    case MortonSwizzleMode::LinearToMorton:
-        return linear_to_morton_fns[static_cast<std::size_t>(format)];
-    }
-}
-
-/// 8x8 Z-Order coordinate from 2D coordinates
-static u32 MortonInterleave(u32 x, u32 y) {
-    static const u32 xlut[] = {0x00, 0x01, 0x04, 0x05, 0x10, 0x11, 0x14, 0x15};
-    static const u32 ylut[] = {0x00, 0x02, 0x08, 0x0a, 0x20, 0x22, 0x28, 0x2a};
-    return xlut[x % 8] + ylut[y % 8];
-}
-
-/// Calculates the offset of the position of the pixel in Morton order
-static u32 GetMortonOffset(u32 x, u32 y, u32 bytes_per_pixel) {
-    // Images are split into 8x8 tiles. Each tile is composed of four 4x4 subtiles each
-    // of which is composed of four 2x2 subtiles each of which is composed of four texels.
-    // Each structure is embedded into the next-bigger one in a diagonal pattern, e.g.
-    // texels are laid out in a 2x2 subtile like this:
-    // 2 3
-    // 0 1
-    //
-    // The full 8x8 tile has the texels arranged like this:
-    //
-    // 42 43 46 47 58 59 62 63
-    // 40 41 44 45 56 57 60 61
-    // 34 35 38 39 50 51 54 55
-    // 32 33 36 37 48 49 52 53
-    // 10 11 14 15 26 27 30 31
-    // 08 09 12 13 24 25 28 29
-    // 02 03 06 07 18 19 22 23
-    // 00 01 04 05 16 17 20 21
-    //
-    // This pattern is what's called Z-order curve, or Morton order.
-
-    const unsigned int block_height = 8;
-    const unsigned int coarse_x = x & ~7;
-
-    u32 i = MortonInterleave(x, y);
-
-    const unsigned int offset = coarse_x * block_height;
-
-    return (i + offset) * bytes_per_pixel;
-}
-
-static u32 MortonInterleave128(u32 x, u32 y) {
-    // 128x128 Z-Order coordinate from 2D coordinates
-    static constexpr u32 xlut[] = {
-        0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042,
-        0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809,
-        0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000,
-        0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043,
-        0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a,
-        0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001,
-        0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048,
-        0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b,
-        0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002,
-        0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049,
-        0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840,
-        0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003,
-        0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a,
-        0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841,
-        0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008,
-        0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b,
-        0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842,
-        0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009,
-        0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800,
-        0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843,
-        0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a,
-        0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801,
-        0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848,
-        0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b,
-        0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802,
-        0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849,
-        0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040,
-        0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803,
-        0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a,
-        0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041,
-        0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808,
-        0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b,
-        0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042,
-        0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809,
-        0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b,
-    };
-    static constexpr u32 ylut[] = {
-        0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090,
-        0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124,
-        0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200,
-        0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294,
-        0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330,
-        0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404,
-        0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0,
-        0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534,
-        0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610,
-        0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4,
-        0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780,
-        0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014,
-        0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0,
-        0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184,
-        0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220,
-        0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4,
-        0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390,
-        0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424,
-        0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500,
-        0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594,
-        0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630,
-        0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704,
-        0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0,
-        0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034,
-        0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110,
-        0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4,
-        0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280,
-        0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314,
-        0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0,
-        0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484,
-        0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520,
-        0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4,
-        0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690,
-        0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724,
-        0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4,
-    };
-    return xlut[x % 128] + ylut[y % 128];
-}
-
-static u32 GetMortonOffset128(u32 x, u32 y, u32 bytes_per_pixel) {
-    // Calculates the offset of the position of the pixel in Morton order
-    // Framebuffer images are split into 128x128 tiles.
-
-    constexpr u32 block_height = 128;
-    const u32 coarse_x = x & ~127;
-
-    const u32 i = MortonInterleave128(x, y);
-
-    const u32 offset = coarse_x * block_height;
-
-    return (i + offset) * bytes_per_pixel;
-}
-
-void MortonSwizzle(MortonSwizzleMode mode, Surface::PixelFormat format, u32 stride,
-                   u32 block_height, u32 height, u32 block_depth, u32 depth, u8* buffer,
-                   std::size_t buffer_size, VAddr addr) {
-
-    GetSwizzleFunction(mode, format)(stride, block_height, height, block_depth, depth, buffer,
-                                     buffer_size, addr);
-}
-
-void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixel, u32 linear_bytes_per_pixel,
-                         u8* morton_data, u8* linear_data, bool morton_to_linear) {
-    u8* data_ptrs[2];
-    for (u32 y = 0; y < height; ++y) {
-        for (u32 x = 0; x < width; ++x) {
-            const u32 coarse_y = y & ~127;
-            const u32 morton_offset =
-                GetMortonOffset128(x, y, bytes_per_pixel) + coarse_y * width * bytes_per_pixel;
-            const u32 linear_pixel_index = (x + y * width) * linear_bytes_per_pixel;
-
-            data_ptrs[morton_to_linear ? 1 : 0] = morton_data + morton_offset;
-            data_ptrs[morton_to_linear ? 0 : 1] = &linear_data[linear_pixel_index];
-
-            std::memcpy(data_ptrs[0], data_ptrs[1], bytes_per_pixel);
-        }
-    }
-}
-
-} // namespace VideoCore

src/video_core/morton.h

@@ -1,21 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "video_core/surface.h"
-
-namespace VideoCore {
-
-enum class MortonSwizzleMode { MortonToLinear, LinearToMorton };
-
-void MortonSwizzle(MortonSwizzleMode mode, VideoCore::Surface::PixelFormat format, u32 stride,
-                   u32 block_height, u32 height, u32 block_depth, u32 depth, u8* buffer,
-                   std::size_t buffer_size, VAddr addr);
-
-void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixel, u32 linear_bytes_per_pixel,
-                         u8* morton_data, u8* linear_data, bool morton_to_linear);
-
-} // namespace VideoCore

src/video_core/renderer_opengl/gl_global_cache.cpp

@@ -1,96 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "core/core.h"
-#include "core/memory.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/renderer_opengl/gl_global_cache.h"
-#include "video_core/renderer_opengl/gl_rasterizer.h"
-#include "video_core/renderer_opengl/gl_shader_cache.h"
-#include "video_core/renderer_opengl/gl_shader_manager.h"
-#include "video_core/renderer_opengl/utils.h"
-
-namespace OpenGL {
-
-CachedGlobalRegion::CachedGlobalRegion(VAddr addr, u32 size) : addr{addr}, size{size} {
-    buffer.Create();
-    LabelGLObject(GL_BUFFER, buffer.handle, addr);
-}
-
-/// Helper function to get the maximum size we can use for an OpenGL uniform block
-static u32 GetMaxUniformBlockSize() {
-    GLint max_size{};
-    glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &max_size);
-    return static_cast<u32>(max_size);
-}
-
-void CachedGlobalRegion::Reload(u32 size_) {
-    static const u32 max_size{GetMaxUniformBlockSize()};
-
-    size = size_;
-    if (size > max_size) {
-        size = max_size;
-        LOG_CRITICAL(HW_GPU, "Global region size {} exceeded max UBO size of {}!", size_, max_size);
-    }
-
-    glBindBuffer(GL_UNIFORM_BUFFER, buffer.handle);
-    glBufferData(GL_UNIFORM_BUFFER, size, Memory::GetPointer(addr), GL_DYNAMIC_DRAW);
-}
-
-GlobalRegion GlobalRegionCacheOpenGL::TryGetReservedGlobalRegion(VAddr addr, u32 size) const {
-    auto search{reserve.find(addr)};
-    if (search == reserve.end()) {
-        return {};
-    }
-    return search->second;
-}
-
-GlobalRegion GlobalRegionCacheOpenGL::GetUncachedGlobalRegion(VAddr addr, u32 size) {
-    GlobalRegion region{TryGetReservedGlobalRegion(addr, size)};
-    if (!region) {
-        // No reserved surface available, create a new one and reserve it
-        region = std::make_shared<CachedGlobalRegion>(addr, size);
-        ReserveGlobalRegion(region);
-    }
-    region->Reload(size);
-    return region;
-}
-
-void GlobalRegionCacheOpenGL::ReserveGlobalRegion(const GlobalRegion& region) {
-    reserve[region->GetAddr()] = region;
-}
-
-GlobalRegionCacheOpenGL::GlobalRegionCacheOpenGL(RasterizerOpenGL& rasterizer)
-    : RasterizerCache{rasterizer} {}
-
-GlobalRegion GlobalRegionCacheOpenGL::GetGlobalRegion(
-    const Tegra::Engines::Maxwell3D::GlobalMemoryDescriptor& global_region,
-    Tegra::Engines::Maxwell3D::Regs::ShaderStage stage) {
-    auto& gpu{Core::System::GetInstance().GPU()};
-    const auto cbufs = gpu.Maxwell3D().state.shader_stages[static_cast<u64>(stage)];
-    const auto cbuf_addr{gpu.MemoryManager().GpuToCpuAddress(
-        cbufs.const_buffers[global_region.cbuf_index].address + global_region.cbuf_offset)};
-
-    ASSERT(cbuf_addr);
-
-    const auto actual_addr_gpu = Memory::Read64(*cbuf_addr);
-    const auto size = Memory::Read32(*cbuf_addr + 8);
-    const auto actual_addr{gpu.MemoryManager().GpuToCpuAddress(actual_addr_gpu)};
-
-    ASSERT(actual_addr);
-
-    // Look up global region in the cache based on address
-    GlobalRegion region{TryGet(*actual_addr)};
-
-    if (!region) {
-        // No global region found - create a new one
-        region = GetUncachedGlobalRegion(*actual_addr, size);
-        Register(region);
-    }
-
-    return region;
-}
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_global_cache.h

@@ -1,89 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <fmt/format.h>
-#include "common/common_types.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/rasterizer_cache.h"
-#include "video_core/renderer_opengl/gl_resource_manager.h"
-
-namespace OpenGL {
-
-class RasterizerOpenGL;
-class CachedGlobalRegion;
-using GlobalRegion = std::shared_ptr<CachedGlobalRegion>;
-
-/// Helper class for caching global region uniform locations
-class CachedGlobalRegionUniform {
-public:
-    explicit CachedGlobalRegionUniform(std::size_t index) : index{index} {}
-
-    std::string GetName() const {
-        return fmt::format("global_memory_region_declblock_{}", index);
-    }
-
-    u32 GetHash() const {
-        // This needs to be unique from ConstBufferEntry::GetHash and SamplerEntry::GetHash
-        return (static_cast<u32>(index) << 16) | 0xFFFF;
-    }
-
-private:
-    std::size_t index{};
-};
-
-class CachedGlobalRegion final : public RasterizerCacheObject {
-public:
-    CachedGlobalRegion(VAddr addr, u32 size);
-
-    /// Gets the address of the shader in guest memory, required for cache management
-    VAddr GetAddr() const {
-        return addr;
-    }
-
-    /// Gets the size of the shader in guest memory, required for cache management
-    std::size_t GetSizeInBytes() const {
-        return size;
-    }
-
-    /// Gets the GL program handle for the buffer
-    GLuint GetBufferHandle() const {
-        return buffer.handle;
-    }
-
-    /// Reloads the global region from guest memory
-    void Reload(u32 size_);
-
-    // We do not have to flush this cache as things in it are never modified by us.
-    void Flush() override {}
-
-private:
-    VAddr addr;
-    u32 size;
-
-    OGLBuffer buffer;
-};
-
-class GlobalRegionCacheOpenGL final : public RasterizerCache<GlobalRegion> {
-public:
-    explicit GlobalRegionCacheOpenGL(RasterizerOpenGL& rasterizer);
-
-    /// Gets the current specified shader stage program
-    GlobalRegion GetGlobalRegion(
-        const Tegra::Engines::Maxwell3D::GlobalMemoryDescriptor& descriptor,
-        Tegra::Engines::Maxwell3D::Regs::ShaderStage stage);
-
-private:
-    GlobalRegion TryGetReservedGlobalRegion(VAddr addr, u32 size) const;
-    GlobalRegion GetUncachedGlobalRegion(VAddr addr, u32 size);
-    void ReserveGlobalRegion(const GlobalRegion& region);
-
-    std::unordered_map<VAddr, GlobalRegion> reserve;
-};
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -81,7 +81,7 @@ struct DrawParameters {
 
 RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo& info)
     : res_cache{*this}, shader_cache{*this}, emu_window{window}, screen_info{info},
-      buffer_cache(*this, STREAM_BUFFER_SIZE), global_cache{*this} {
+      buffer_cache(*this, STREAM_BUFFER_SIZE) {
     // Create sampler objects
     for (std::size_t i = 0; i < texture_samplers.size(); ++i) {
         texture_samplers[i].Create();
@@ -98,9 +98,14 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo
             has_ARB_direct_state_access = true;
         } else if (extension == "GL_ARB_multi_bind") {
             has_ARB_multi_bind = true;
+        } else if (extension == "GL_ARB_separate_shader_objects") {
+            has_ARB_separate_shader_objects = true;
+        } else if (extension == "GL_ARB_vertex_attrib_binding") {
+            has_ARB_vertex_attrib_binding = true;
         }
     }
 
+    ASSERT_MSG(has_ARB_separate_shader_objects, "has_ARB_separate_shader_objects is unsupported");
     OpenGLState::ApplyDefaultState();
 
     // Create render framebuffer
@@ -113,10 +118,43 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo
     glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uniform_buffer_alignment);
 
     LOG_CRITICAL(Render_OpenGL, "Sync fixed function OpenGL state here!");
+    CheckExtensions();
 }
 
 RasterizerOpenGL::~RasterizerOpenGL() {}
 
+void RasterizerOpenGL::CheckExtensions() {
+    if (!GLAD_GL_ARB_texture_filter_anisotropic && !GLAD_GL_EXT_texture_filter_anisotropic) {
+        LOG_WARNING(
+            Render_OpenGL,
+            "Anisotropic filter is not supported! this can cause graphical issues in some games.");
+    }
+    if (!GLAD_GL_ARB_viewport_array) {
+        LOG_WARNING(Render_OpenGL, "Viewport arrays are not supported! this can potyentially cause "
+                                   "issues in games that use geometry shaders.");
+    }
+    if (!GLAD_GL_ARB_color_buffer_float) {
+        LOG_WARNING(
+            Render_OpenGL,
+            "Color clamp control is not supported! this can cause graphical issues in some games.");
+    }
+    if (!GLAD_GL_ARB_buffer_storage) {
+        LOG_WARNING(
+            Render_OpenGL,
+            "Buffer storage control is not supported! this can cause performance degradation.");
+    }
+    if (!GLAD_GL_AMD_depth_clamp_separate) {
+        if (!GLAD_GL_ARB_depth_clamp) {
+            LOG_WARNING(
+                Render_OpenGL,
+                "Depth Clamp is not supported! this can cause graphical issues in some games.");
+        } else {
+            LOG_WARNING(Render_OpenGL, "Separate Depth Clamp is not supported! this can cause "
+                                       "graphical issues in some games.");
+        }
+    }
+}
+
 void RasterizerOpenGL::SetupVertexFormat() {
     auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
     const auto& regs = gpu.regs;
@@ -261,13 +299,18 @@ DrawParameters RasterizerOpenGL::SetupDraw() {
     return params;
 }
 
+bool RasterizerOpenGL::GeometryShaderActive() {
+    const auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
+    return gpu.regs.IsShaderConfigEnabled(static_cast<size_t>(Maxwell::ShaderProgram::Geometry));
+}
+
 void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
     MICROPROFILE_SCOPE(OpenGL_Shader);
     const auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
 
     // Next available bindpoints to use when uploading the const buffers and textures to the GLSL
     // shaders. The constbuffer bindpoint starts after the shader stage configuration bind points.
-    u32 current_buffer_bindpoint = Tegra::Engines::Maxwell3D::Regs::MaxShaderStage;
+    u32 current_constbuffer_bindpoint = Tegra::Engines::Maxwell3D::Regs::MaxShaderStage;
     u32 current_texture_bindpoint = 0;
 
     for (std::size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
@@ -321,14 +364,9 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
         }
 
         // Configure the const buffers for this shader stage.
-        current_buffer_bindpoint =
+        current_constbuffer_bindpoint =
             SetupConstBuffers(static_cast<Maxwell::ShaderStage>(stage), shader, primitive_mode,
-                              current_buffer_bindpoint);
-
-        // Configure global memory regions for this shader stage.
-        current_buffer_bindpoint =
-            SetupGlobalRegions(static_cast<Maxwell::ShaderStage>(stage), shader, primitive_mode,
-                               current_buffer_bindpoint);
+                              current_constbuffer_bindpoint);
 
         // Configure the textures for this shader stage.
         current_texture_bindpoint = SetupTextures(static_cast<Maxwell::ShaderStage>(stage), shader,
@@ -543,7 +581,7 @@ void RasterizerOpenGL::Clear() {
         use_stencil = true;
         clear_state.stencil.test_enabled = true;
         if (regs.clear_flags.stencil) {
-            // Stencil affects the clear so fill it with the used masks
+            // Stencil affects the clear so  fill it with the used masks
             clear_state.stencil.front.test_func = GL_ALWAYS;
             clear_state.stencil.front.test_mask = regs.stencil_front_func_mask;
             clear_state.stencil.front.action_stencil_fail = GL_KEEP;
@@ -582,7 +620,8 @@ void RasterizerOpenGL::Clear() {
     }
 
     if (regs.clear_flags.viewport) {
-        clear_state.EmulateViewportWithScissor();
+        // Viewport does not affects glClearBuffer so emulate viewport using  Scissor
+        clear_state.TranslateViewportToScissor();
     }
 
     clear_state.Apply();
@@ -609,7 +648,7 @@ void RasterizerOpenGL::DrawArrays() {
     const auto& regs = gpu.regs;
 
     ScopeAcquireGLContext acquire_context{emu_window};
-
+    state.geometry_shaders.enabled = GeometryShaderActive();
     ConfigureFramebuffers(state);
     SyncColorMask();
     SyncFragmentColorClampState();
@@ -700,7 +739,6 @@ void RasterizerOpenGL::InvalidateRegion(VAddr addr, u64 size) {
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
     res_cache.InvalidateRegion(addr, size);
     shader_cache.InvalidateRegion(addr, size);
-    global_cache.InvalidateRegion(addr, size);
     buffer_cache.InvalidateRegion(addr, size);
 }
 
@@ -925,29 +963,6 @@ u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, Shader& shad
     return current_bindpoint + static_cast<u32>(entries.size());
 }
 
-u32 RasterizerOpenGL::SetupGlobalRegions(Maxwell::ShaderStage stage, Shader& shader,
-                                         GLenum primitive_mode, u32 current_bindpoint) {
-    std::size_t global_region_index{};
-    const auto& maxwell3d{Core::System::GetInstance().GPU().Maxwell3D()};
-    for (const auto& global_region : maxwell3d.state.global_memory_uniforms) {
-        const auto& region{
-            global_cache.GetGlobalRegion(global_region, static_cast<Maxwell::ShaderStage>(stage))};
-        const GLenum b_index{
-            shader->GetProgramResourceIndex(CachedGlobalRegionUniform{global_region_index})};
-
-        if (b_index != GL_INVALID_INDEX) {
-            glBindBufferBase(GL_UNIFORM_BUFFER, current_bindpoint, region->GetBufferHandle());
-            glUniformBlockBinding(shader->GetProgramHandle(primitive_mode), b_index,
-                                  current_bindpoint);
-            ++current_bindpoint;
-        }
-
-        ++global_region_index;
-    }
-
-    return current_bindpoint;
-}
-
 u32 RasterizerOpenGL::SetupTextures(Maxwell::ShaderStage stage, Shader& shader,
                                     GLenum primitive_mode, u32 current_unit) {
     MICROPROFILE_SCOPE(OpenGL_Texture);
@@ -998,16 +1013,28 @@ u32 RasterizerOpenGL::SetupTextures(Maxwell::ShaderStage stage, Shader& shader,
 
 void RasterizerOpenGL::SyncViewport(OpenGLState& current_state) {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
-    for (std::size_t i = 0; i < Tegra::Engines::Maxwell3D::Regs::NumViewports; i++) {
-        const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[i].GetRect()};
+    const std::size_t viewport_count =
+        current_state.geometry_shaders.enabled ? Tegra::Engines::Maxwell3D::Regs::NumViewports : 1;
+    for (std::size_t i = 0; i < viewport_count; i++) {
         auto& viewport = current_state.viewports[i];
-        viewport.x = viewport_rect.left;
-        viewport.y = viewport_rect.bottom;
-        viewport.width = viewport_rect.GetWidth();
-        viewport.height = viewport_rect.GetHeight();
+        const auto& src = regs.viewports[i];
+        if (regs.viewport_transform_enabled) {
+            const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[i].GetRect()};
+            viewport.x = viewport_rect.left;
+            viewport.y = viewport_rect.bottom;
+            viewport.width = viewport_rect.GetWidth();
+            viewport.height = viewport_rect.GetHeight();
+        } else {
+            viewport.x = src.x;
+            viewport.y = src.y;
+            viewport.width = src.width;
+            viewport.height = src.height;
+        }
         viewport.depth_range_far = regs.viewports[i].depth_range_far;
         viewport.depth_range_near = regs.viewports[i].depth_range_near;
     }
+    current_state.depth_clamp.far_plane = regs.view_volume_clip_control.depth_clamp_far != 0;
+    current_state.depth_clamp.near_plane = regs.view_volume_clip_control.depth_clamp_near != 0;
 }
 
 void RasterizerOpenGL::SyncClipEnabled() {
@@ -1178,7 +1205,9 @@ void RasterizerOpenGL::SyncLogicOpState() {
 
 void RasterizerOpenGL::SyncScissorTest(OpenGLState& current_state) {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
-    for (std::size_t i = 0; i < Tegra::Engines::Maxwell3D::Regs::NumViewports; i++) {
+    const std::size_t viewport_count =
+        current_state.geometry_shaders.enabled ? Tegra::Engines::Maxwell3D::Regs::NumViewports : 1;
+    for (std::size_t i = 0; i < viewport_count; i++) {
         const auto& src = regs.scissor_test[i];
         auto& dst = current_state.viewports[i].scissor;
         dst.enabled = (src.enable != 0);

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -23,7 +23,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_global_cache.h"
 #include "video_core/renderer_opengl/gl_primitive_assembler.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
@@ -102,7 +101,7 @@ private:
         Tegra::Texture::DepthCompareFunc depth_compare_func =
             Tegra::Texture::DepthCompareFunc::Always;
         GLvec4 border_color = {};
-        float min_lod = 0.0f;
+        float min_lod = 0.f;
         float max_lod = 16.0f;
         float lod_bias = 0.0f;
         float max_anisotropic = 1.0f;
@@ -119,7 +118,7 @@ private:
                                bool using_depth_fb = true, bool preserve_contents = true,
                                std::optional<std::size_t> single_color_target = {});
 
-    /**
+    /*
      * Configures the current constbuffers to use for the draw command.
      * @param stage The shader stage to configure buffers for.
      * @param shader The shader object that contains the specified stage.
@@ -129,17 +128,7 @@ private:
     u32 SetupConstBuffers(Tegra::Engines::Maxwell3D::Regs::ShaderStage stage, Shader& shader,
                           GLenum primitive_mode, u32 current_bindpoint);
 
-    /**
-     * Configures the current global memory regions to use for the draw command.
-     * @param stage The shader stage to configure buffers for.
-     * @param shader The shader object that contains the specified stage.
-     * @param current_bindpoint The offset at which to start counting new buffer bindpoints.
-     * @returns The next available bindpoint for use in the next shader stage.
-     */
-    u32 SetupGlobalRegions(Tegra::Engines::Maxwell3D::Regs::ShaderStage stage, Shader& shader,
-                           GLenum primitive_mode, u32 current_bindpoint);
-
-    /**
+    /*
      * Configures the current textures to use for the draw command.
      * @param stage The shader stage to configure textures for.
      * @param shader The shader object that contains the specified stage.
@@ -197,14 +186,19 @@ private:
     /// Check asserts for alpha testing.
     void CheckAlphaTests();
 
+    /// check for extension that are not strictly required
+    /// but are needed for correct emulation
+    void CheckExtensions();
+
     bool has_ARB_direct_state_access = false;
     bool has_ARB_multi_bind = false;
+    bool has_ARB_separate_shader_objects = false;
+    bool has_ARB_vertex_attrib_binding = false;
 
     OpenGLState state;
 
     RasterizerCacheOpenGL res_cache;
     ShaderCacheOpenGL shader_cache;
-    GlobalRegionCacheOpenGL global_cache;
 
     Core::Frontend::EmuWindow& emu_window;
 
@@ -234,6 +228,7 @@ private:
     DrawParameters SetupDraw();
 
     void SetupShaders(GLenum primitive_mode);
+    bool GeometryShaderActive();
 
     enum class AccelDraw { Disabled, Arrays, Indexed };
     AccelDraw accelerate_draw = AccelDraw::Disabled;

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -15,7 +15,6 @@
 #include "core/memory.h"
 #include "core/settings.h"
 #include "video_core/engines/maxwell_3d.h"
-#include "video_core/morton.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_state.h"
@@ -23,11 +22,10 @@
 #include "video_core/surface.h"
 #include "video_core/textures/astc.h"
 #include "video_core/textures/decoders.h"
+#include "video_core/utils.h"
 
 namespace OpenGL {
 
-using VideoCore::MortonSwizzle;
-using VideoCore::MortonSwizzleMode;
 using VideoCore::Surface::ComponentTypeFromDepthFormat;
 using VideoCore::Surface::ComponentTypeFromRenderTarget;
 using VideoCore::Surface::ComponentTypeFromTexture;
@@ -267,11 +265,11 @@ static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex
     {GL_COMPRESSED_RG_RGTC2, GL_RG, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true},                                                                     // DXN2UNORM
     {GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, GL_INT, ComponentType::SNorm, true}, // DXN2SNORM
-    {GL_COMPRESSED_RGBA_BPTC_UNORM, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+    {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true}, // BC7U
-    {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::Float,
-     true}, // BC6H_UF16
-    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::Float,
+    {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8,
+     ComponentType::Float, true}, // BC6H_UF16
+    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::Float,
      true},                                                                    // BC6H_SF16
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_4X4
     {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // G8R8U
@@ -308,8 +306,8 @@ static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex
      true}, // DXT23_SRGB
     {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true}, // DXT45_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-     true},                                                                    // BC7U_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8,
+     ComponentType::UNorm, true},                                              // BC7U_SRGB
     {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4_SRGB
     {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X8_SRGB
     {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X5_SRGB
@@ -348,7 +346,7 @@ static GLenum SurfaceTargetToGL(SurfaceTarget target) {
     case SurfaceTarget::TextureCubemap:
         return GL_TEXTURE_CUBE_MAP;
     case SurfaceTarget::TextureCubeArray:
-        return GL_TEXTURE_CUBE_MAP_ARRAY;
+        return GL_TEXTURE_CUBE_MAP_ARRAY_ARB;
     }
     LOG_CRITICAL(Render_OpenGL, "Unimplemented texture target={}", static_cast<u32>(target));
     UNREACHABLE();
@@ -372,7 +370,174 @@ MathUtil::Rectangle<u32> SurfaceParams::GetRect(u32 mip_level) const {
     return {0, actual_height, MipWidth(mip_level), 0};
 }
 
-void SwizzleFunc(const MortonSwizzleMode& mode, const SurfaceParams& params,
+template <bool morton_to_gl, PixelFormat format>
+void MortonCopy(u32 stride, u32 block_height, u32 height, u32 block_depth, u32 depth, u8* gl_buffer,
+                std::size_t gl_buffer_size, VAddr addr) {
+    constexpr u32 bytes_per_pixel = GetBytesPerPixel(format);
+
+    // With the BCn formats (DXT and DXN), each 4x4 tile is swizzled instead of just individual
+    // pixel values.
+    const u32 tile_size_x{GetDefaultBlockWidth(format)};
+    const u32 tile_size_y{GetDefaultBlockHeight(format)};
+
+    if (morton_to_gl) {
+        Tegra::Texture::UnswizzleTexture(gl_buffer, addr, tile_size_x, tile_size_y, bytes_per_pixel,
+                                         stride, height, depth, block_height, block_depth);
+    } else {
+        Tegra::Texture::CopySwizzledData((stride + tile_size_x - 1) / tile_size_x,
+                                         (height + tile_size_y - 1) / tile_size_y, depth,
+                                         bytes_per_pixel, bytes_per_pixel, Memory::GetPointer(addr),
+                                         gl_buffer, false, block_height, block_depth);
+    }
+}
+
+using GLConversionArray = std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr),
+                                     VideoCore::Surface::MaxPixelFormat>;
+
+static constexpr GLConversionArray morton_to_gl_fns = {
+    // clang-format off
+        MortonCopy<true, PixelFormat::ABGR8U>,
+        MortonCopy<true, PixelFormat::ABGR8S>,
+        MortonCopy<true, PixelFormat::ABGR8UI>,
+        MortonCopy<true, PixelFormat::B5G6R5U>,
+        MortonCopy<true, PixelFormat::A2B10G10R10U>,
+        MortonCopy<true, PixelFormat::A1B5G5R5U>,
+        MortonCopy<true, PixelFormat::R8U>,
+        MortonCopy<true, PixelFormat::R8UI>,
+        MortonCopy<true, PixelFormat::RGBA16F>,
+        MortonCopy<true, PixelFormat::RGBA16U>,
+        MortonCopy<true, PixelFormat::RGBA16UI>,
+        MortonCopy<true, PixelFormat::R11FG11FB10F>,
+        MortonCopy<true, PixelFormat::RGBA32UI>,
+        MortonCopy<true, PixelFormat::DXT1>,
+        MortonCopy<true, PixelFormat::DXT23>,
+        MortonCopy<true, PixelFormat::DXT45>,
+        MortonCopy<true, PixelFormat::DXN1>,
+        MortonCopy<true, PixelFormat::DXN2UNORM>,
+        MortonCopy<true, PixelFormat::DXN2SNORM>,
+        MortonCopy<true, PixelFormat::BC7U>,
+        MortonCopy<true, PixelFormat::BC6H_UF16>,
+        MortonCopy<true, PixelFormat::BC6H_SF16>,
+        MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
+        MortonCopy<true, PixelFormat::G8R8U>,
+        MortonCopy<true, PixelFormat::G8R8S>,
+        MortonCopy<true, PixelFormat::BGRA8>,
+        MortonCopy<true, PixelFormat::RGBA32F>,
+        MortonCopy<true, PixelFormat::RG32F>,
+        MortonCopy<true, PixelFormat::R32F>,
+        MortonCopy<true, PixelFormat::R16F>,
+        MortonCopy<true, PixelFormat::R16U>,
+        MortonCopy<true, PixelFormat::R16S>,
+        MortonCopy<true, PixelFormat::R16UI>,
+        MortonCopy<true, PixelFormat::R16I>,
+        MortonCopy<true, PixelFormat::RG16>,
+        MortonCopy<true, PixelFormat::RG16F>,
+        MortonCopy<true, PixelFormat::RG16UI>,
+        MortonCopy<true, PixelFormat::RG16I>,
+        MortonCopy<true, PixelFormat::RG16S>,
+        MortonCopy<true, PixelFormat::RGB32F>,
+        MortonCopy<true, PixelFormat::RGBA8_SRGB>,
+        MortonCopy<true, PixelFormat::RG8U>,
+        MortonCopy<true, PixelFormat::RG8S>,
+        MortonCopy<true, PixelFormat::RG32UI>,
+        MortonCopy<true, PixelFormat::R32UI>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X8>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X5>,
+        MortonCopy<true, PixelFormat::ASTC_2D_5X4>,
+        MortonCopy<true, PixelFormat::BGRA8_SRGB>,
+        MortonCopy<true, PixelFormat::DXT1_SRGB>,
+        MortonCopy<true, PixelFormat::DXT23_SRGB>,
+        MortonCopy<true, PixelFormat::DXT45_SRGB>,
+        MortonCopy<true, PixelFormat::BC7U_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_4X4_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X8_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X5_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_5X4_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_5X5>,
+        MortonCopy<true, PixelFormat::ASTC_2D_5X5_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_10X8>,
+        MortonCopy<true, PixelFormat::ASTC_2D_10X8_SRGB>,
+        MortonCopy<true, PixelFormat::Z32F>,
+        MortonCopy<true, PixelFormat::Z16>,
+        MortonCopy<true, PixelFormat::Z24S8>,
+        MortonCopy<true, PixelFormat::S8Z24>,
+        MortonCopy<true, PixelFormat::Z32FS8>,
+    // clang-format on
+};
+
+static constexpr GLConversionArray gl_to_morton_fns = {
+    // clang-format off
+        MortonCopy<false, PixelFormat::ABGR8U>,
+        MortonCopy<false, PixelFormat::ABGR8S>,
+        MortonCopy<false, PixelFormat::ABGR8UI>,
+        MortonCopy<false, PixelFormat::B5G6R5U>,
+        MortonCopy<false, PixelFormat::A2B10G10R10U>,
+        MortonCopy<false, PixelFormat::A1B5G5R5U>,
+        MortonCopy<false, PixelFormat::R8U>,
+        MortonCopy<false, PixelFormat::R8UI>,
+        MortonCopy<false, PixelFormat::RGBA16F>,
+        MortonCopy<false, PixelFormat::RGBA16U>,
+        MortonCopy<false, PixelFormat::RGBA16UI>,
+        MortonCopy<false, PixelFormat::R11FG11FB10F>,
+        MortonCopy<false, PixelFormat::RGBA32UI>,
+        MortonCopy<false, PixelFormat::DXT1>,
+        MortonCopy<false, PixelFormat::DXT23>,
+        MortonCopy<false, PixelFormat::DXT45>,
+        MortonCopy<false, PixelFormat::DXN1>,
+        MortonCopy<false, PixelFormat::DXN2UNORM>,
+        MortonCopy<false, PixelFormat::DXN2SNORM>,
+        MortonCopy<false, PixelFormat::BC7U>,
+        MortonCopy<false, PixelFormat::BC6H_UF16>,
+        MortonCopy<false, PixelFormat::BC6H_SF16>,
+        // TODO(Subv): Swizzling ASTC formats are not supported
+        nullptr,
+        MortonCopy<false, PixelFormat::G8R8U>,
+        MortonCopy<false, PixelFormat::G8R8S>,
+        MortonCopy<false, PixelFormat::BGRA8>,
+        MortonCopy<false, PixelFormat::RGBA32F>,
+        MortonCopy<false, PixelFormat::RG32F>,
+        MortonCopy<false, PixelFormat::R32F>,
+        MortonCopy<false, PixelFormat::R16F>,
+        MortonCopy<false, PixelFormat::R16U>,
+        MortonCopy<false, PixelFormat::R16S>,
+        MortonCopy<false, PixelFormat::R16UI>,
+        MortonCopy<false, PixelFormat::R16I>,
+        MortonCopy<false, PixelFormat::RG16>,
+        MortonCopy<false, PixelFormat::RG16F>,
+        MortonCopy<false, PixelFormat::RG16UI>,
+        MortonCopy<false, PixelFormat::RG16I>,
+        MortonCopy<false, PixelFormat::RG16S>,
+        MortonCopy<false, PixelFormat::RGB32F>,
+        MortonCopy<false, PixelFormat::RGBA8_SRGB>,
+        MortonCopy<false, PixelFormat::RG8U>,
+        MortonCopy<false, PixelFormat::RG8S>,
+        MortonCopy<false, PixelFormat::RG32UI>,
+        MortonCopy<false, PixelFormat::R32UI>,
+        nullptr,
+        nullptr,
+        nullptr,
+        MortonCopy<false, PixelFormat::BGRA8_SRGB>,
+        MortonCopy<false, PixelFormat::DXT1_SRGB>,
+        MortonCopy<false, PixelFormat::DXT23_SRGB>,
+        MortonCopy<false, PixelFormat::DXT45_SRGB>,
+        MortonCopy<false, PixelFormat::BC7U_SRGB>,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        MortonCopy<false, PixelFormat::Z32F>,
+        MortonCopy<false, PixelFormat::Z16>,
+        MortonCopy<false, PixelFormat::Z24S8>,
+        MortonCopy<false, PixelFormat::S8Z24>,
+        MortonCopy<false, PixelFormat::Z32FS8>,
+    // clang-format on
+};
+
+void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params,
                  std::vector<u8>& gl_buffer, u32 mip_level) {
     u32 depth = params.MipDepth(mip_level);
     if (params.target == SurfaceTarget::Texture2D) {
@@ -385,19 +550,19 @@ void SwizzleFunc(const MortonSwizzleMode& mode, const SurfaceParams& params,
         const u64 layer_size = params.LayerMemorySize();
         const u64 gl_size = params.LayerSizeGL(mip_level);
         for (u32 i = 0; i < params.depth; i++) {
-            MortonSwizzle(mode, params.pixel_format, params.MipWidth(mip_level),
-                          params.MipBlockHeight(mip_level), params.MipHeight(mip_level),
-                          params.MipBlockDepth(mip_level), 1, gl_buffer.data() + offset_gl, gl_size,
-                          params.addr + offset);
+            functions[static_cast<std::size_t>(params.pixel_format)](
+                params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
+                params.MipHeight(mip_level), params.MipBlockDepth(mip_level), 1,
+                gl_buffer.data() + offset_gl, gl_size, params.addr + offset);
             offset += layer_size;
             offset_gl += gl_size;
         }
     } else {
         const u64 offset = params.GetMipmapLevelOffset(mip_level);
-        MortonSwizzle(mode, params.pixel_format, params.MipWidth(mip_level),
-                      params.MipBlockHeight(mip_level), params.MipHeight(mip_level),
-                      params.MipBlockDepth(mip_level), depth, gl_buffer.data(), gl_buffer.size(),
-                      params.addr + offset);
+        functions[static_cast<std::size_t>(params.pixel_format)](
+            params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
+            params.MipHeight(mip_level), params.MipBlockDepth(mip_level), depth, gl_buffer.data(),
+            gl_buffer.size(), params.addr + offset);
     }
 }
 
@@ -561,7 +726,7 @@ static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
     const std::size_t buffer_size = std::max(src_params.size_in_bytes, dst_params.size_in_bytes);
 
     glBindBuffer(GL_PIXEL_PACK_BUFFER, copy_pbo_handle);
-    glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW);
+    glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW_ARB);
     if (source_format.compressed) {
         glGetCompressedTextureImage(src_surface->Texture().handle, src_attachment,
                                     static_cast<GLsizei>(src_params.size_in_bytes), nullptr);
@@ -831,7 +996,7 @@ void CachedSurface::LoadGLBuffer() {
         ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                    params.block_width, static_cast<u32>(params.target));
         for (u32 i = 0; i < params.max_mip_level; i++)
-            SwizzleFunc(MortonSwizzleMode::MortonToLinear, params, gl_buffer[i], i);
+            SwizzleFunc(morton_to_gl_fns, params, gl_buffer[i], i);
     } else {
         const auto texture_src_data{Memory::GetPointer(params.addr)};
         const auto texture_src_data_end{texture_src_data + params.size_in_bytes_gl};
@@ -870,7 +1035,7 @@ void CachedSurface::FlushGLBuffer() {
         ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                    params.block_width, static_cast<u32>(params.target));
 
-        SwizzleFunc(MortonSwizzleMode::LinearToMorton, params, gl_buffer[0], 0);
+        SwizzleFunc(gl_to_morton_fns, params, gl_buffer[0], 0);
     } else {
         std::memcpy(Memory::GetPointer(GetAddr()), gl_buffer[0].data(), GetSizeInBytes());
     }

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -84,7 +84,6 @@ CachedShader::CachedShader(VAddr addr, Maxwell::ShaderProgram program_type)
     }
 
     entries = program_result.second;
-    shader_length = entries.shader_length;
 
     if (program_type != Maxwell::ShaderProgram::Geometry) {
         OGLShader shader;
@@ -98,6 +97,18 @@ CachedShader::CachedShader(VAddr addr, Maxwell::ShaderProgram program_type)
     }
 }
 
+GLuint CachedShader::GetProgramResourceIndex(const GLShader::ConstBufferEntry& buffer) {
+    const auto search{resource_cache.find(buffer.GetHash())};
+    if (search == resource_cache.end()) {
+        const GLuint index{
+            glGetProgramResourceIndex(program.handle, GL_UNIFORM_BLOCK, buffer.GetName().c_str())};
+        resource_cache[buffer.GetHash()] = index;
+        return index;
+    }
+
+    return search->second;
+}
+
 GLint CachedShader::GetUniformLocation(const GLShader::SamplerEntry& sampler) {
     const auto search{uniform_cache.find(sampler.GetHash())};
     if (search == uniform_cache.end()) {

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -30,7 +30,7 @@ public:
     }
 
     std::size_t GetSizeInBytes() const override {
-        return shader_length;
+        return GLShader::MAX_PROGRAM_CODE_LENGTH * sizeof(u64);
     }
 
     // We do not have to flush this cache as things in it are never modified by us.
@@ -71,18 +71,7 @@ public:
     }
 
     /// Gets the GL program resource location for the specified resource, caching as needed
-    template <typename T>
-    GLuint GetProgramResourceIndex(const T& buffer) {
-        const auto& search{resource_cache.find(buffer.GetHash())};
-        if (search == resource_cache.end()) {
-            const GLuint index{glGetProgramResourceIndex(program.handle, GL_UNIFORM_BLOCK,
-                                                         buffer.GetName().c_str())};
-            resource_cache[buffer.GetHash()] = index;
-            return index;
-        }
-
-        return search->second;
-    }
+    GLuint GetProgramResourceIndex(const GLShader::ConstBufferEntry& buffer);
 
     /// Gets the GL uniform location for the specified resource, caching as needed
     GLint GetUniformLocation(const GLShader::SamplerEntry& sampler);
@@ -93,7 +82,6 @@ private:
                                u32 max_vertices, const std::string& debug_name);
 
     VAddr addr;
-    std::size_t shader_length;
     Maxwell::ShaderProgram program_type;
     GLShader::ShaderSetup setup;
     GLShader::ShaderEntries entries;

src/video_core/renderer_opengl/gl_shader_gen.h

@@ -57,8 +57,7 @@ public:
     }
 
     u32 GetHash() const {
-        // This needs to be unique from CachedGlobalRegionUniform::GetHash
-        return (static_cast<u32>(stage) << 12) | index;
+        return (static_cast<u32>(stage) << 16) | index;
     }
 
 private:
@@ -139,8 +138,7 @@ public:
     }
 
     u32 GetHash() const {
-        // This needs to be unique from CachedGlobalRegionUniform::GetHash
-        return (static_cast<u32>(stage) << 12) | static_cast<u32>(sampler_index);
+        return (static_cast<u32>(stage) << 16) | static_cast<u32>(sampler_index);
     }
 
     static std::string GetArrayName(Maxwell::ShaderStage stage) {
@@ -165,7 +163,6 @@ private:
 struct ShaderEntries {
     std::vector<ConstBufferEntry> const_buffer_entries;
     std::vector<SamplerEntry> texture_samplers;
-    std::size_t shader_length;
 };
 
 using ProgramResult = std::pair<std::string, ShaderEntries>;

src/video_core/renderer_opengl/gl_state.cpp

@@ -92,6 +92,8 @@ OpenGLState::OpenGLState() {
 
     point.size = 1;
     fragment_color_clamp.enabled = false;
+    depth_clamp.far_plane = false;
+    depth_clamp.near_plane = false;
 }
 
 void OpenGLState::ApplyDefaultState() {
@@ -233,15 +235,15 @@ void OpenGLState::ApplyStencilTest() const {
         config_stencil(GL_BACK, stencil.back, cur_state.stencil.back);
     }
 }
-// Viewport does not affects glClearBuffer so emulate viewport using scissor test
-void OpenGLState::EmulateViewportWithScissor() {
-    auto& current = viewports[0];
+
+void OpenGLState::TranslateViewportToScissor() {
+    auto& current = this->viewports[0];
     if (current.scissor.enabled) {
-        const GLint left = std::max(current.x, current.scissor.x);
-        const GLint right =
+        GLint left = std::max(current.x, current.scissor.x);
+        GLint right =
             std::max(current.x + current.width, current.scissor.x + current.scissor.width);
-        const GLint bottom = std::max(current.y, current.scissor.y);
-        const GLint top =
+        GLint bottom = std::max(current.y, current.scissor.y);
+        GLint top =
             std::max(current.y + current.height, current.scissor.y + current.scissor.height);
         current.scissor.x = std::max(left, 0);
         current.scissor.y = std::max(bottom, 0);
@@ -362,14 +364,14 @@ void OpenGLState::ApplyTargetBlending(std::size_t target, bool force) const {
     if (blend_changed || updated.src_rgb_func != current.src_rgb_func ||
         updated.dst_rgb_func != current.dst_rgb_func || updated.src_a_func != current.src_a_func ||
         updated.dst_a_func != current.dst_a_func) {
-        glBlendFuncSeparatei(static_cast<GLuint>(target), updated.src_rgb_func,
-                             updated.dst_rgb_func, updated.src_a_func, updated.dst_a_func);
+        glBlendFuncSeparateiARB(static_cast<GLuint>(target), updated.src_rgb_func,
+                                updated.dst_rgb_func, updated.src_a_func, updated.dst_a_func);
     }
 
     if (blend_changed || updated.rgb_equation != current.rgb_equation ||
         updated.a_equation != current.a_equation) {
-        glBlendEquationSeparatei(static_cast<GLuint>(target), updated.rgb_equation,
-                                 updated.a_equation);
+        glBlendEquationSeparateiARB(static_cast<GLuint>(target), updated.rgb_equation,
+                                    updated.a_equation);
     }
 }
 
@@ -506,6 +508,29 @@ void OpenGLState::Apply() const {
                          fragment_color_clamp.enabled ? GL_TRUE : GL_FALSE);
         }
     }
+    if (depth_clamp.far_plane != cur_state.depth_clamp.far_plane ||
+        depth_clamp.near_plane != cur_state.depth_clamp.near_plane) {
+        if (GLAD_GL_AMD_depth_clamp_separate) {
+            if (depth_clamp.far_plane) {
+                glEnable(GL_DEPTH_CLAMP_FAR_AMD);
+            } else {
+                glDisable(GL_DEPTH_CLAMP_FAR_AMD);
+            }
+            if (depth_clamp.near_plane) {
+                glEnable(GL_DEPTH_CLAMP_NEAR_AMD);
+            } else {
+                glDisable(GL_DEPTH_CLAMP_NEAR_AMD);
+            }
+        } else {
+            if (depth_clamp.far_plane || depth_clamp.near_plane) {
+                glEnable(GL_DEPTH_CLAMP);
+            } else {
+                glDisable(GL_DEPTH_CLAMP);
+            }
+            UNIMPLEMENTED_IF_MSG(depth_clamp.far_plane != depth_clamp.near_plane,
+                                 "Unimplemented Depth Clamp Separation!");
+        }
+    }
     if (multisample_control.alpha_to_coverage != cur_state.multisample_control.alpha_to_coverage) {
         if (multisample_control.alpha_to_coverage) {
             glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);

src/video_core/renderer_opengl/gl_state.h

@@ -48,6 +48,11 @@ public:
         bool enabled; // GL_CLAMP_FRAGMENT_COLOR_ARB
     } fragment_color_clamp;
 
+    struct {
+        bool far_plane;
+        bool near_plane;
+    } depth_clamp; // GL_DEPTH_CLAMP
+
     struct {
         bool enabled; // viewports arrays are only supported when geometry shaders are enabled.
     } geometry_shaders;
@@ -206,7 +211,7 @@ public:
     OpenGLState& ResetBuffer(GLuint handle);
     OpenGLState& ResetVertexArray(GLuint handle);
     OpenGLState& ResetFramebuffer(GLuint handle);
-    void EmulateViewportWithScissor();
+    void TranslateViewportToScissor();
 
 private:
     static OpenGLState cur_state;

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -218,19 +218,14 @@ inline GLenum DepthCompareFunc(Tegra::Texture::DepthCompareFunc func) {
 inline GLenum BlendEquation(Maxwell::Blend::Equation equation) {
     switch (equation) {
     case Maxwell::Blend::Equation::Add:
-    case Maxwell::Blend::Equation::AddGL:
         return GL_FUNC_ADD;
     case Maxwell::Blend::Equation::Subtract:
-    case Maxwell::Blend::Equation::SubtractGL:
         return GL_FUNC_SUBTRACT;
     case Maxwell::Blend::Equation::ReverseSubtract:
-    case Maxwell::Blend::Equation::ReverseSubtractGL:
         return GL_FUNC_REVERSE_SUBTRACT;
     case Maxwell::Blend::Equation::Min:
-    case Maxwell::Blend::Equation::MinGL:
         return GL_MIN;
     case Maxwell::Blend::Equation::Max:
-    case Maxwell::Blend::Equation::MaxGL:
         return GL_MAX;
     }
     LOG_ERROR(Render_OpenGL, "Unimplemented blend equation={}", static_cast<u32>(equation));

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -19,9 +19,9 @@
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "core/tracer/recorder.h"
-#include "video_core/morton.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
+#include "video_core/utils.h"
 
 namespace OpenGL {
 
@@ -490,7 +490,7 @@ bool RendererOpenGL::Init() {
     Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_Model", gpu_model);
     Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_OpenGL_Version", gl_version);
 
-    if (!GLAD_GL_VERSION_4_3) {
+    if (!GLAD_GL_VERSION_3_3) {
         return false;
     }
 

src/video_core/utils.h

@@ -0,0 +1,164 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace VideoCore {
+
+// 8x8 Z-Order coordinate from 2D coordinates
+static inline u32 MortonInterleave(u32 x, u32 y) {
+    static const u32 xlut[] = {0x00, 0x01, 0x04, 0x05, 0x10, 0x11, 0x14, 0x15};
+    static const u32 ylut[] = {0x00, 0x02, 0x08, 0x0a, 0x20, 0x22, 0x28, 0x2a};
+    return xlut[x % 8] + ylut[y % 8];
+}
+
+/**
+ * Calculates the offset of the position of the pixel in Morton order
+ */
+static inline u32 GetMortonOffset(u32 x, u32 y, u32 bytes_per_pixel) {
+    // Images are split into 8x8 tiles. Each tile is composed of four 4x4 subtiles each
+    // of which is composed of four 2x2 subtiles each of which is composed of four texels.
+    // Each structure is embedded into the next-bigger one in a diagonal pattern, e.g.
+    // texels are laid out in a 2x2 subtile like this:
+    // 2 3
+    // 0 1
+    //
+    // The full 8x8 tile has the texels arranged like this:
+    //
+    // 42 43 46 47 58 59 62 63
+    // 40 41 44 45 56 57 60 61
+    // 34 35 38 39 50 51 54 55
+    // 32 33 36 37 48 49 52 53
+    // 10 11 14 15 26 27 30 31
+    // 08 09 12 13 24 25 28 29
+    // 02 03 06 07 18 19 22 23
+    // 00 01 04 05 16 17 20 21
+    //
+    // This pattern is what's called Z-order curve, or Morton order.
+
+    const unsigned int block_height = 8;
+    const unsigned int coarse_x = x & ~7;
+
+    u32 i = VideoCore::MortonInterleave(x, y);
+
+    const unsigned int offset = coarse_x * block_height;
+
+    return (i + offset) * bytes_per_pixel;
+}
+
+static inline u32 MortonInterleave128(u32 x, u32 y) {
+    // 128x128 Z-Order coordinate from 2D coordinates
+    static constexpr u32 xlut[] = {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042,
+        0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809,
+        0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000,
+        0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043,
+        0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a,
+        0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001,
+        0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048,
+        0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b,
+        0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002,
+        0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049,
+        0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840,
+        0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003,
+        0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a,
+        0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841,
+        0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008,
+        0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b,
+        0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842,
+        0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009,
+        0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800,
+        0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843,
+        0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a,
+        0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801,
+        0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848,
+        0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802,
+        0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849,
+        0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040,
+        0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803,
+        0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a,
+        0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041,
+        0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808,
+        0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b,
+        0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042,
+        0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809,
+        0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b,
+    };
+    static constexpr u32 ylut[] = {
+        0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090,
+        0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124,
+        0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200,
+        0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294,
+        0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330,
+        0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404,
+        0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0,
+        0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534,
+        0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610,
+        0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4,
+        0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780,
+        0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014,
+        0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0,
+        0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184,
+        0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220,
+        0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4,
+        0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390,
+        0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424,
+        0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500,
+        0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594,
+        0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630,
+        0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704,
+        0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0,
+        0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034,
+        0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110,
+        0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4,
+        0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280,
+        0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314,
+        0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0,
+        0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484,
+        0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520,
+        0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4,
+        0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690,
+        0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724,
+        0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4,
+    };
+    return xlut[x % 128] + ylut[y % 128];
+}
+
+static inline u32 GetMortonOffset128(u32 x, u32 y, u32 bytes_per_pixel) {
+    // Calculates the offset of the position of the pixel in Morton order
+    // Framebuffer images are split into 128x128 tiles.
+
+    const unsigned int block_height = 128;
+    const unsigned int coarse_x = x & ~127;
+
+    u32 i = MortonInterleave128(x, y);
+
+    const unsigned int offset = coarse_x * block_height;
+
+    return (i + offset) * bytes_per_pixel;
+}
+
+static inline void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixel,
+                                       u32 gl_bytes_per_pixel, u8* morton_data, u8* gl_data,
+                                       bool morton_to_gl) {
+    u8* data_ptrs[2];
+    for (unsigned y = 0; y < height; ++y) {
+        for (unsigned x = 0; x < width; ++x) {
+            const u32 coarse_y = y & ~127;
+            u32 morton_offset =
+                GetMortonOffset128(x, y, bytes_per_pixel) + coarse_y * width * bytes_per_pixel;
+            u32 gl_pixel_index = (x + y * width) * gl_bytes_per_pixel;
+
+            data_ptrs[morton_to_gl] = morton_data + morton_offset;
+            data_ptrs[!morton_to_gl] = &gl_data[gl_pixel_index];
+
+            memcpy(data_ptrs[0], data_ptrs[1], bytes_per_pixel);
+        }
+    }
+}
+
+} // namespace VideoCore

src/yuzu/applets/software_keyboard.cpp

@@ -82,8 +82,8 @@ QtSoftwareKeyboardDialog::QtSoftwareKeyboardDialog(
                            : QString::fromStdU16String(parameters.submit_text),
                        QDialogButtonBox::AcceptRole);
 
-    connect(buttons, &QDialogButtonBox::accepted, this, &QtSoftwareKeyboardDialog::accept);
-    connect(buttons, &QDialogButtonBox::rejected, this, &QtSoftwareKeyboardDialog::reject);
+    connect(buttons, &QDialogButtonBox::accepted, this, &QtSoftwareKeyboardDialog::Submit);
+    connect(buttons, &QDialogButtonBox::rejected, this, &QtSoftwareKeyboardDialog::Reject);
     layout->addWidget(header_label);
     layout->addWidget(sub_label);
     layout->addWidget(guide_label);
@@ -96,16 +96,16 @@ QtSoftwareKeyboardDialog::QtSoftwareKeyboardDialog(
 
 QtSoftwareKeyboardDialog::~QtSoftwareKeyboardDialog() = default;
 
-void QtSoftwareKeyboardDialog::accept() {
+void QtSoftwareKeyboardDialog::Submit() {
     ok = true;
     text = line_edit->text().toStdU16String();
-    QDialog::accept();
+    accept();
 }
 
-void QtSoftwareKeyboardDialog::reject() {
+void QtSoftwareKeyboardDialog::Reject() {
     ok = false;
     text.clear();
-    QDialog::reject();
+    accept();
 }
 
 std::u16string QtSoftwareKeyboardDialog::GetText() const {
@@ -129,13 +129,13 @@ QtSoftwareKeyboard::~QtSoftwareKeyboard() = default;
 
 void QtSoftwareKeyboard::RequestText(std::function<void(std::optional<std::u16string>)> out,
                                      Core::Frontend::SoftwareKeyboardParameters parameters) const {
-    text_output = std::move(out);
+    text_output = out;
     emit MainWindowGetText(parameters);
 }
 
 void QtSoftwareKeyboard::SendTextCheckDialog(std::u16string error_message,
                                              std::function<void()> finished_check) const {
-    this->finished_check = std::move(finished_check);
+    this->finished_check = finished_check;
     emit MainWindowTextCheckDialog(error_message);
 }
 

src/yuzu/applets/software_keyboard.h

@@ -33,8 +33,8 @@ public:
                              Core::Frontend::SoftwareKeyboardParameters parameters);
     ~QtSoftwareKeyboardDialog() override;
 
-    void accept() override;
-    void reject() override;
+    void Submit();
+    void Reject();
 
     std::u16string GetText() const;
     bool GetStatus() const;
@@ -70,10 +70,11 @@ signals:
     void MainWindowGetText(Core::Frontend::SoftwareKeyboardParameters parameters) const;
     void MainWindowTextCheckDialog(std::u16string error_message) const;
 
-private:
+public slots:
     void MainWindowFinishedText(std::optional<std::u16string> text);
     void MainWindowFinishedCheckDialog();
 
+private:
     mutable std::function<void(std::optional<std::u16string>)> text_output;
     mutable std::function<void()> finished_check;
 };

src/yuzu/bootmanager.cpp

@@ -310,7 +310,7 @@ void GRenderWindow::InitRenderTarget() {
     // TODO: One of these flags might be interesting: WA_OpaquePaintEvent, WA_NoBackground,
     // WA_DontShowOnScreen, WA_DeleteOnClose
     QGLFormat fmt;
-    fmt.setVersion(4, 3);
+    fmt.setVersion(3, 3);
     fmt.setProfile(QGLFormat::CoreProfile);
     fmt.setSwapInterval(false);
 

src/yuzu/configuration/config.cpp

@@ -432,7 +432,6 @@ void Config::ReadValues() {
     Settings::values.use_gdbstub = qt_config->value("use_gdbstub", false).toBool();
     Settings::values.gdbstub_port = qt_config->value("gdbstub_port", 24689).toInt();
     Settings::values.program_args = qt_config->value("program_args", "").toString().toStdString();
-    Settings::values.dump_exefs = qt_config->value("dump_exefs", false).toBool();
     Settings::values.dump_nso = qt_config->value("dump_nso", false).toBool();
     qt_config->endGroup();
 
@@ -639,7 +638,6 @@ void Config::SaveValues() {
     qt_config->setValue("use_gdbstub", Settings::values.use_gdbstub);
     qt_config->setValue("gdbstub_port", Settings::values.gdbstub_port);
     qt_config->setValue("program_args", QString::fromStdString(Settings::values.program_args));
-    qt_config->setValue("dump_exefs", Settings::values.dump_exefs);
     qt_config->setValue("dump_nso", Settings::values.dump_nso);
     qt_config->endGroup();
 

src/yuzu/configuration/configure_debug.cpp

@@ -34,7 +34,6 @@ void ConfigureDebug::setConfiguration() {
     ui->toggle_console->setChecked(UISettings::values.show_console);
     ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter));
     ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values.program_args));
-    ui->dump_exefs->setChecked(Settings::values.dump_exefs);
     ui->dump_decompressed_nso->setChecked(Settings::values.dump_nso);
 }
 
@@ -44,7 +43,6 @@ void ConfigureDebug::applyConfiguration() {
     UISettings::values.show_console = ui->toggle_console->isChecked();
     Settings::values.log_filter = ui->log_filter_edit->text().toStdString();
     Settings::values.program_args = ui->homebrew_args_edit->text().toStdString();
-    Settings::values.dump_exefs = ui->dump_exefs->isChecked();
     Settings::values.dump_nso = ui->dump_decompressed_nso->isChecked();
     Debugger::ToggleConsole();
     Log::Filter filter;

src/yuzu/configuration/configure_debug.ui

@@ -145,16 +145,6 @@
         </property>
        </widget>
       </item>
-      <item>
-       <widget class="QCheckBox" name="dump_exefs">
-        <property name="whatsThis">
-         <string>When checked, any game that yuzu loads will have its ExeFS dumped to the yuzu/dump directory.</string>
-        </property>
-        <property name="text">
-         <string>Dump ExeFS</string>
-        </property>
-       </widget>
-      </item>
      </layout>
     </widget>
    </item>

src/yuzu/configuration/configure_graphics.ui

@@ -23,31 +23,31 @@
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_2">
         <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_2">
-          <item>
-           <widget class="QCheckBox" name="toggle_frame_limit">
-            <property name="text">
-             <string>Limit Speed Percent</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QSpinBox" name="frame_limit">
-            <property name="suffix">
-             <string>%</string>
-            </property>
-            <property name="minimum">
-             <number>1</number>
-            </property>
-            <property name="maximum">
-             <number>9999</number>
-            </property>
-            <property name="value">
-             <number>100</number>
-            </property>
-           </widget>
-          </item>
-         </layout>
+          <layout class="QHBoxLayout" name="horizontalLayout_2">
+            <item>
+              <widget class="QCheckBox" name="toggle_frame_limit">
+                <property name="text">
+                  <string>Limit Speed Percent</string>
+                </property>
+              </widget>
+            </item>
+            <item>
+              <widget class="QSpinBox" name="frame_limit">
+                <property name="suffix">
+                  <string>%</string>
+                </property>
+                <property name="minimum">
+                  <number>1</number>
+                </property>
+                <property name="maximum">
+                  <number>9999</number>
+                </property>
+                <property name="value">
+                  <number>100</number>
+                </property>
+              </widget>
+            </item>
+          </layout>
         </item>
         <item>
          <widget class="QCheckBox" name="use_accurate_gpu_emulation">
@@ -61,7 +61,7 @@
           <item>
            <widget class="QLabel" name="label">
             <property name="text">
-             <string>Internal Resolution</string>
+             <string>Internal Resolution:(Currently does nothing.)</string>
             </property>
            </widget>
           </item>
@@ -96,27 +96,27 @@
           </item>
          </layout>
         </item>
-        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_6">
-          <item>
-           <widget class="QLabel" name="bg_label">
-            <property name="text">
-             <string>Background Color:</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QPushButton" name="bg_button">
-            <property name="maximumSize">
-             <size>
-              <width>40</width>
-              <height>16777215</height>
-             </size>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
+         <item>
+           <layout class="QHBoxLayout" name="horizontalLayout_6">
+             <item>
+               <widget class="QLabel" name="bg_label">
+                 <property name="text">
+                   <string>Background Color:</string>
+                 </property>
+               </widget>
+             </item>
+             <item>
+               <widget class="QPushButton" name="bg_button">
+                 <property name="maximumSize">
+                   <size>
+                     <width>40</width>
+                     <height>16777215</height>
+                   </size>
+                 </property>
+               </widget>
+             </item>
+           </layout>
+         </item>
        </layout>
       </widget>
      </item>

src/yuzu/main.cpp

@@ -518,18 +518,32 @@ void GMainWindow::OnDisplayTitleBars(bool show) {
 QStringList GMainWindow::GetUnsupportedGLExtensions() {
     QStringList unsupported_ext;
 
+    if (!GLAD_GL_ARB_program_interface_query)
+        unsupported_ext.append("ARB_program_interface_query");
+    if (!GLAD_GL_ARB_separate_shader_objects)
+        unsupported_ext.append("ARB_separate_shader_objects");
+    if (!GLAD_GL_ARB_vertex_attrib_binding)
+        unsupported_ext.append("ARB_vertex_attrib_binding");
     if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev)
         unsupported_ext.append("ARB_vertex_type_10f_11f_11f_rev");
     if (!GLAD_GL_ARB_texture_mirror_clamp_to_edge)
         unsupported_ext.append("ARB_texture_mirror_clamp_to_edge");
+    if (!GLAD_GL_ARB_base_instance)
+        unsupported_ext.append("ARB_base_instance");
+    if (!GLAD_GL_ARB_texture_storage)
+        unsupported_ext.append("ARB_texture_storage");
     if (!GLAD_GL_ARB_multi_bind)
         unsupported_ext.append("ARB_multi_bind");
+    if (!GLAD_GL_ARB_copy_image)
+        unsupported_ext.append("ARB_copy_image");
 
     // Extensions required to support some texture formats.
     if (!GLAD_GL_EXT_texture_compression_s3tc)
         unsupported_ext.append("EXT_texture_compression_s3tc");
     if (!GLAD_GL_ARB_texture_compression_rgtc)
         unsupported_ext.append("ARB_texture_compression_rgtc");
+    if (!GLAD_GL_ARB_texture_compression_bptc)
+        unsupported_ext.append("ARB_texture_compression_bptc");
     if (!GLAD_GL_ARB_depth_buffer_float)
         unsupported_ext.append("ARB_depth_buffer_float");
 
@@ -548,8 +562,8 @@ bool GMainWindow::LoadROM(const QString& filename) {
     render_window->MakeCurrent();
 
     if (!gladLoadGL()) {
-        QMessageBox::critical(this, tr("Error while initializing OpenGL 4.3 Core!"),
-                              tr("Your GPU may not support OpenGL 4.3, or you do not "
+        QMessageBox::critical(this, tr("Error while initializing OpenGL 3.3 Core!"),
+                              tr("Your GPU may not support OpenGL 3.3, or you do not "
                                  "have the latest graphics driver."));
         return false;
     }

src/yuzu_cmd/config.cpp

@@ -366,7 +366,6 @@ void Config::ReadValues() {
     Settings::values.gdbstub_port =
         static_cast<u16>(sdl2_config->GetInteger("Debugging", "gdbstub_port", 24689));
     Settings::values.program_args = sdl2_config->Get("Debugging", "program_args", "");
-    Settings::values.dump_exefs = sdl2_config->GetBoolean("Debugging", "dump_exefs", false);
     Settings::values.dump_nso = sdl2_config->GetBoolean("Debugging", "dump_nso", false);
 
     // Web Service

src/yuzu_cmd/default_ini.h

@@ -206,8 +206,6 @@ log_filter = *:Trace
 # Port for listening to GDB connections.
 use_gdbstub=false
 gdbstub_port=24689
-# Determines whether or not yuzu will dump the ExeFS of all games it attempts to load while loading them
-dump_exefs=false
 # Determines whether or not yuzu will dump all NSOs it attempts to load while loading them
 dump_nso=false
 

src/yuzu_cmd/emu_window/emu_window_sdl2.cpp

@@ -111,18 +111,32 @@ void EmuWindow_SDL2::Fullscreen() {
 bool EmuWindow_SDL2::SupportsRequiredGLExtensions() {
     std::vector<std::string> unsupported_ext;
 
+    if (!GLAD_GL_ARB_program_interface_query)
+        unsupported_ext.push_back("ARB_program_interface_query");
+    if (!GLAD_GL_ARB_separate_shader_objects)
+        unsupported_ext.push_back("ARB_separate_shader_objects");
+    if (!GLAD_GL_ARB_vertex_attrib_binding)
+        unsupported_ext.push_back("ARB_vertex_attrib_binding");
     if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev)
         unsupported_ext.push_back("ARB_vertex_type_10f_11f_11f_rev");
     if (!GLAD_GL_ARB_texture_mirror_clamp_to_edge)
         unsupported_ext.push_back("ARB_texture_mirror_clamp_to_edge");
+    if (!GLAD_GL_ARB_base_instance)
+        unsupported_ext.push_back("ARB_base_instance");
+    if (!GLAD_GL_ARB_texture_storage)
+        unsupported_ext.push_back("ARB_texture_storage");
     if (!GLAD_GL_ARB_multi_bind)
         unsupported_ext.push_back("ARB_multi_bind");
+    if (!GLAD_GL_ARB_copy_image)
+        unsupported_ext.push_back("ARB_copy_image");
 
     // Extensions required to support some texture formats.
     if (!GLAD_GL_EXT_texture_compression_s3tc)
         unsupported_ext.push_back("EXT_texture_compression_s3tc");
     if (!GLAD_GL_ARB_texture_compression_rgtc)
         unsupported_ext.push_back("ARB_texture_compression_rgtc");
+    if (!GLAD_GL_ARB_texture_compression_bptc)
+        unsupported_ext.push_back("ARB_texture_compression_bptc");
     if (!GLAD_GL_ARB_depth_buffer_float)
         unsupported_ext.push_back("ARB_depth_buffer_float");
 
@@ -143,7 +157,7 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
         exit(1);
     }
 
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
     SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
     SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);