Merge 8035c9fb4a into 6828c25498

VS 2017 provides the char16_t and char32_t types, so the ifdef isn't necessary
anymore.

CMakeLists.txt

@@ -1,5 +1,5 @@
-cmake_minimum_required(VERSION 3.7)
-
+# CMake 3.6 required for FindBoost to define IMPORTED libs properly on unknown Boost versions
+cmake_minimum_required(VERSION 3.6)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
 include(DownloadExternals)
@@ -187,8 +187,8 @@ find_package(Threads REQUIRED)
 if (ENABLE_SDL2)
     if (YUZU_USE_BUNDLED_SDL2)
         # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.0.8")
+        if (MSVC14 AND ARCHITECTURE_x86_64)
+            set(SDL2_VER "SDL2-2.0.5")
         else()
             message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
         endif()
@@ -220,7 +220,7 @@ if (YUZU_USE_BUNDLED_UNICORN)
     if (MSVC)
         message(STATUS "unicorn not found, falling back to bundled")
         # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
+        if (MSVC14 AND ARCHITECTURE_x86_64)
             set(UNICORN_VER "unicorn-yuzu")
         else()
             message(FATAL_ERROR "No bundled Unicorn binaries for your toolchain. Disable YUZU_USE_BUNDLED_UNICORN and provide your own.")
@@ -279,7 +279,7 @@ endif()
 
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
+        if (MSVC14 AND ARCHITECTURE_x86_64)
             set(QT_VER qt-5.10.0-msvc2015_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
@@ -303,7 +303,7 @@ endif()
 # ======================================
 
 IF (APPLE)
-    find_library(COCOA_LIBRARY Cocoa)           # Umbrella framework for everything GUI-related
+    FIND_LIBRARY(COCOA_LIBRARY Cocoa)           # Umbrella framework for everything GUI-related
     set(PLATFORM_LIBRARIES ${COCOA_LIBRARY} ${IOKIT_LIBRARY} ${COREVIDEO_LIBRARY})
 
     if (CMAKE_CXX_COMPILER_ID STREQUAL Clang)

src/audio_core/CMakeLists.txt

@@ -1,8 +1,4 @@
 add_library(audio_core STATIC
-    algorithm/filter.cpp
-    algorithm/filter.h
-    algorithm/interpolate.cpp
-    algorithm/interpolate.h
     audio_out.cpp
     audio_out.h
     audio_renderer.cpp
@@ -11,12 +7,12 @@ add_library(audio_core STATIC
     codec.cpp
     codec.h
     null_sink.h
+    stream.cpp
+    stream.h
     sink.h
     sink_details.cpp
     sink_details.h
     sink_stream.h
-    stream.cpp
-    stream.h
 
     $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
 )

src/audio_core/algorithm/filter.cpp

@@ -1,79 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#define _USE_MATH_DEFINES
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <vector>
-#include "audio_core/algorithm/filter.h"
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-Filter Filter::LowPass(double cutoff, double Q) {
-    const double w0 = 2.0 * M_PI * cutoff;
-    const double sin_w0 = std::sin(w0);
-    const double cos_w0 = std::cos(w0);
-    const double alpha = sin_w0 / (2 * Q);
-
-    const double a0 = 1 + alpha;
-    const double a1 = -2.0 * cos_w0;
-    const double a2 = 1 - alpha;
-    const double b0 = 0.5 * (1 - cos_w0);
-    const double b1 = 1.0 * (1 - cos_w0);
-    const double b2 = 0.5 * (1 - cos_w0);
-
-    return {a0, a1, a2, b0, b1, b2};
-}
-
-Filter::Filter() : Filter(1.0, 0.0, 0.0, 1.0, 0.0, 0.0) {}
-
-Filter::Filter(double a0, double a1, double a2, double b0, double b1, double b2)
-    : a1(a1 / a0), a2(a2 / a0), b0(b0 / a0), b1(b1 / a0), b2(b2 / a0) {}
-
-void Filter::Process(std::vector<s16>& signal) {
-    const size_t num_frames = signal.size() / 2;
-    for (size_t i = 0; i < num_frames; i++) {
-        std::rotate(in.begin(), in.end() - 1, in.end());
-        std::rotate(out.begin(), out.end() - 1, out.end());
-
-        for (size_t ch = 0; ch < channel_count; ch++) {
-            in[0][ch] = signal[i * channel_count + ch];
-
-            out[0][ch] = b0 * in[0][ch] + b1 * in[1][ch] + b2 * in[2][ch] - a1 * out[1][ch] -
-                         a2 * out[2][ch];
-
-            signal[i * 2 + ch] = std::clamp(out[0][ch], -32768.0, 32767.0);
-        }
-    }
-}
-
-/// Calculates the appropriate Q for each biquad in a cascading filter.
-/// @param total_count The total number of biquads to be cascaded.
-/// @param index 0-index of the biquad to calculate the Q value for.
-static double CascadingBiquadQ(size_t total_count, size_t index) {
-    const double pole = M_PI * (2 * index + 1) / (4.0 * total_count);
-    return 1.0 / (2.0 * std::cos(pole));
-}
-
-CascadingFilter CascadingFilter::LowPass(double cutoff, size_t cascade_size) {
-    std::vector<Filter> cascade(cascade_size);
-    for (size_t i = 0; i < cascade_size; i++) {
-        cascade[i] = Filter::LowPass(cutoff, CascadingBiquadQ(cascade_size, i));
-    }
-    return CascadingFilter{std::move(cascade)};
-}
-
-CascadingFilter::CascadingFilter() = default;
-CascadingFilter::CascadingFilter(std::vector<Filter> filters) : filters(std::move(filters)) {}
-
-void CascadingFilter::Process(std::vector<s16>& signal) {
-    for (auto& filter : filters) {
-        filter.Process(signal);
-    }
-}
-
-} // namespace AudioCore

src/audio_core/algorithm/filter.h

@@ -1,62 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <vector>
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-/// Digital biquad filter:
-///
-///          b0 + b1 z^-1 + b2 z^-2
-///  H(z) = ------------------------
-///          a0 + a1 z^-1 + b2 z^-2
-class Filter {
-public:
-    /// Creates a low-pass filter.
-    /// @param cutoff Determines the cutoff frequency. A value from 0.0 to 1.0.
-    /// @param Q Determines the quality factor of this filter.
-    static Filter LowPass(double cutoff, double Q = 0.7071);
-
-    /// Passthrough filter.
-    Filter();
-
-    Filter(double a0, double a1, double a2, double b0, double b1, double b2);
-
-    void Process(std::vector<s16>& signal);
-
-private:
-    static constexpr size_t channel_count = 2;
-
-    /// Coefficients are in normalized form (a0 = 1.0).
-    double a1, a2, b0, b1, b2;
-    /// Input History
-    std::array<std::array<double, channel_count>, 3> in;
-    /// Output History
-    std::array<std::array<double, channel_count>, 3> out;
-};
-
-/// Cascade filters to build up higher-order filters from lower-order ones.
-class CascadingFilter {
-public:
-    /// Creates a cascading low-pass filter.
-    /// @param cutoff Determines the cutoff frequency. A value from 0.0 to 1.0.
-    /// @param cascade_size Number of biquads in cascade.
-    static CascadingFilter LowPass(double cutoff, size_t cascade_size);
-
-    /// Passthrough.
-    CascadingFilter();
-
-    explicit CascadingFilter(std::vector<Filter> filters);
-
-    void Process(std::vector<s16>& signal);
-
-private:
-    std::vector<Filter> filters;
-};
-
-} // namespace AudioCore

src/audio_core/algorithm/interpolate.cpp

@@ -1,71 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#define _USE_MATH_DEFINES
-
-#include <algorithm>
-#include <cmath>
-#include <vector>
-#include "audio_core/algorithm/interpolate.h"
-#include "common/common_types.h"
-#include "common/logging/log.h"
-
-namespace AudioCore {
-
-/// The Lanczos kernel
-static double Lanczos(size_t a, double x) {
-    if (x == 0.0)
-        return 1.0;
-    const double px = M_PI * x;
-    return a * std::sin(px) * std::sin(px / a) / (px * px);
-}
-
-std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input, double ratio) {
-    if (input.size() < 2)
-        return {};
-
-    if (ratio <= 0) {
-        LOG_CRITICAL(Audio, "Nonsensical interpolation ratio {}", ratio);
-        ratio = 1.0;
-    }
-
-    if (ratio != state.current_ratio) {
-        const double cutoff_frequency = std::min(0.5 / ratio, 0.5 * ratio);
-        state.nyquist = CascadingFilter::LowPass(std::clamp(cutoff_frequency, 0.0, 0.4), 3);
-        state.current_ratio = ratio;
-    }
-    state.nyquist.Process(input);
-
-    constexpr size_t taps = InterpolationState::lanczos_taps;
-    const size_t num_frames = input.size() / 2;
-
-    std::vector<s16> output;
-    output.reserve(static_cast<size_t>(input.size() / ratio + 4));
-
-    double& pos = state.position;
-    auto& h = state.history;
-    for (size_t i = 0; i < num_frames; ++i) {
-        std::rotate(h.begin(), h.end() - 1, h.end());
-        h[0][0] = input[i * 2 + 0];
-        h[0][1] = input[i * 2 + 1];
-
-        while (pos <= 1.0) {
-            double l = 0.0;
-            double r = 0.0;
-            for (size_t j = 0; j < h.size(); j++) {
-                l += Lanczos(taps, pos + j - taps + 1) * h[j][0];
-                r += Lanczos(taps, pos + j - taps + 1) * h[j][1];
-            }
-            output.emplace_back(static_cast<s16>(std::clamp(l, -32768.0, 32767.0)));
-            output.emplace_back(static_cast<s16>(std::clamp(r, -32768.0, 32767.0)));
-
-            pos += ratio;
-        }
-        pos -= 1.0;
-    }
-
-    return output;
-}
-
-} // namespace AudioCore

src/audio_core/algorithm/interpolate.h

@@ -1,43 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <vector>
-#include "audio_core/algorithm/filter.h"
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-struct InterpolationState {
-    static constexpr size_t lanczos_taps = 4;
-    static constexpr size_t history_size = lanczos_taps * 2 - 1;
-
-    double current_ratio = 0.0;
-    CascadingFilter nyquist;
-    std::array<std::array<s16, 2>, history_size> history = {};
-    double position = 0;
-};
-
-/// Interpolates input signal to produce output signal.
-/// @param input The signal to interpolate.
-/// @param ratio Interpolation ratio.
-///              ratio > 1.0 results in fewer output samples.
-///              ratio < 1.0 results in more output samples.
-/// @returns Output signal.
-std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input, double ratio);
-
-/// Interpolates input signal to produce output signal.
-/// @param input The signal to interpolate.
-/// @param input_rate The sample rate of input.
-/// @param output_rate The desired sample rate of the output.
-/// @returns Output signal.
-inline std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
-                                    u32 input_rate, u32 output_rate) {
-    const double ratio = static_cast<double>(input_rate) / static_cast<double>(output_rate);
-    return Interpolate(state, std::move(input), ratio);
-}
-
-} // namespace AudioCore

src/audio_core/audio_renderer.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "audio_core/algorithm/interpolate.h"
 #include "audio_core/audio_renderer.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
@@ -27,18 +26,6 @@ AudioRenderer::AudioRenderer(AudioRendererParameter params,
     QueueMixedBuffer(2);
 }
 
-u32 AudioRenderer::GetSampleRate() const {
-    return worker_params.sample_rate;
-}
-
-u32 AudioRenderer::GetSampleCount() const {
-    return worker_params.sample_count;
-}
-
-u32 AudioRenderer::GetMixBufferCount() const {
-    return worker_params.mix_buffer_count;
-}
-
 std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params) {
     // Copy UpdateDataHeader struct
     UpdateDataHeader config{};
@@ -200,8 +187,6 @@ void AudioRenderer::VoiceState::RefreshBuffer() {
         break;
     }
 
-    samples = Interpolate(interp_state, std::move(samples), Info().sample_rate, STREAM_SAMPLE_RATE);
-
     is_refresh_pending = false;
 }
 
@@ -227,7 +212,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                 break;
             }
 
-            samples_remaining -= samples.size() / stream->GetNumChannels();
+            samples_remaining -= samples.size();
 
             for (const auto& sample : samples) {
                 const s32 buffer_sample{buffer[offset]};

src/audio_core/audio_renderer.h

@@ -8,7 +8,6 @@
 #include <memory>
 #include <vector>
 
-#include "audio_core/algorithm/interpolate.h"
 #include "audio_core/audio_out.h"
 #include "audio_core/codec.h"
 #include "audio_core/stream.h"
@@ -27,7 +26,7 @@ enum class PlayState : u8 {
 struct AudioRendererParameter {
     u32_le sample_rate;
     u32_le sample_count;
-    u32_le mix_buffer_count;
+    u32_le unknown_8;
     u32_le unknown_c;
     u32_le voice_count;
     u32_le sink_count;
@@ -161,9 +160,6 @@ public:
     std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);
     void QueueMixedBuffer(Buffer::Tag tag);
     void ReleaseAndQueueBuffers();
-    u32 GetSampleRate() const;
-    u32 GetSampleCount() const;
-    u32 GetMixBufferCount() const;
 
 private:
     class VoiceState {
@@ -195,7 +191,6 @@ private:
         size_t wave_index{};
         size_t offset{};
         Codec::ADPCMState adpcm_state{};
-        InterpolationState interp_state{};
         std::vector<s16> samples;
         VoiceOutStatus out_status{};
         VoiceInfo info{};

src/audio_core/cubeb_sink.cpp

@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include <cstring>
-#include <mutex>
 
 #include "audio_core/cubeb_sink.h"
 #include "audio_core/stream.h"
@@ -67,8 +66,6 @@ public:
             return;
         }
 
-        std::lock_guard lock{queue_mutex};
-
         queue.reserve(queue.size() + samples.size() * GetNumChannels());
 
         if (is_6_channel) {
@@ -97,7 +94,6 @@ private:
     u32 num_channels{};
     bool is_6_channel{};
 
-    std::mutex queue_mutex;
     std::vector<s16> queue;
 
     static long DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
@@ -157,8 +153,6 @@ long SinkStreamImpl::DataCallback(cubeb_stream* stream, void* user_data, const v
         return {};
     }
 
-    std::lock_guard lock{impl->queue_mutex};
-
     const size_t frames_to_write{
         std::min(impl->queue.size() / impl->GetNumChannels(), static_cast<size_t>(num_frames))};
 

src/common/string_util.cpp

@@ -198,27 +198,13 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 #ifdef _WIN32
 
 std::string UTF16ToUTF8(const std::u16string& input) {
-#if _MSC_VER >= 1900
-    // Workaround for missing char16_t/char32_t instantiations in MSVC2015
-    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
-    std::basic_string<__int16> tmp_buffer(input.cbegin(), input.cend());
-    return convert.to_bytes(tmp_buffer);
-#else
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
     return convert.to_bytes(input);
-#endif
 }
 
 std::u16string UTF8ToUTF16(const std::string& input) {
-#if _MSC_VER >= 1900
-    // Workaround for missing char16_t/char32_t instantiations in MSVC2015
-    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
-    auto tmp_buffer = convert.from_bytes(input);
-    return std::u16string(tmp_buffer.cbegin(), tmp_buffer.cend());
-#else
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
     return convert.from_bytes(input);
-#endif
 }
 
 static std::wstring CPToUTF16(u32 code_page, const std::string& input) {

src/common/thread_queue_list.h

@@ -16,7 +16,7 @@ struct ThreadQueueList {
     //               (dynamically resizable) circular buffers to remove their overhead when
     //               inserting and popping.
 
-    using Priority = unsigned int;
+    typedef unsigned int Priority;
 
     // Number of priority levels. (Valid levels are [0..NUM_QUEUES).)
     static const Priority NUM_QUEUES = N;
@@ -26,9 +26,9 @@ struct ThreadQueueList {
     }
 
     // Only for debugging, returns priority level.
-    Priority contains(const T& uid) const {
+    Priority contains(const T& uid) {
         for (Priority i = 0; i < NUM_QUEUES; ++i) {
-            const Queue& cur = queues[i];
+            Queue& cur = queues[i];
             if (std::find(cur.data.cbegin(), cur.data.cend(), uid) != cur.data.cend()) {
                 return i;
             }
@@ -37,8 +37,8 @@ struct ThreadQueueList {
         return -1;
     }
 
-    T get_first() const {
-        const Queue* cur = first;
+    T get_first() {
+        Queue* cur = first;
         while (cur != nullptr) {
             if (!cur->data.empty()) {
                 return cur->data.front();

src/core/CMakeLists.txt

@@ -249,10 +249,6 @@ add_library(core STATIC
     hle/service/nvdrv/devices/nvhost_gpu.h
     hle/service/nvdrv/devices/nvhost_nvdec.cpp
     hle/service/nvdrv/devices/nvhost_nvdec.h
-    hle/service/nvdrv/devices/nvhost_nvjpg.cpp
-    hle/service/nvdrv/devices/nvhost_nvjpg.h
-    hle/service/nvdrv/devices/nvhost_vic.cpp
-    hle/service/nvdrv/devices/nvhost_vic.h
     hle/service/nvdrv/devices/nvmap.cpp
     hle/service/nvdrv/devices/nvmap.h
     hle/service/nvdrv/interface.cpp

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -86,16 +86,7 @@ public:
     }
 
     void AddTicks(u64 ticks) override {
-        // Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a
-        // rough approximation of the amount of executed ticks in the system, it may be thrown off
-        // if not all cores are doing a similar amount of work. Instead of doing this, we should
-        // device a way so that timing is consistent across all cores without increasing the ticks 4
-        // times.
-        u64 amortized_ticks = (ticks - num_interpreted_instructions) / Core::NUM_CPU_CORES;
-        // Always execute at least one tick.
-        amortized_ticks = std::max<u64>(amortized_ticks, 1);
-
-        CoreTiming::AddTicks(amortized_ticks);
+        CoreTiming::AddTicks(ticks - num_interpreted_instructions);
         num_interpreted_instructions = 0;
     }
     u64 GetTicksRemaining() override {
@@ -243,7 +234,9 @@ void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
-    jit->HaltExecution();
+    if (jit->IsExecuting()) {
+        jit->HaltExecution();
+    }
 }
 
 void ARM_Dynarmic::ClearInstructionCache() {

src/core/core.cpp

@@ -88,7 +88,7 @@ System::ResultStatus System::SingleStep() {
     return RunLoop(false);
 }
 
-System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
+System::ResultStatus System::Load(EmuWindow& emu_window, const std::string& filepath) {
     app_loader = Loader::GetLoader(virtual_filesystem->OpenFile(filepath, FileSys::Mode::Read));
 
     if (!app_loader) {
@@ -102,8 +102,18 @@ System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::st
         LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
                      static_cast<int>(system_mode.second));
 
-        if (system_mode.second != Loader::ResultStatus::Success)
+        switch (system_mode.second) {
+        case Loader::ResultStatus::ErrorMissingKeys:
+            return ResultStatus::ErrorLoader_ErrorMissingKeys;
+        case Loader::ResultStatus::ErrorDecrypting:
+            return ResultStatus::ErrorLoader_ErrorDecrypting;
+        case Loader::ResultStatus::ErrorInvalidFormat:
+            return ResultStatus::ErrorLoader_ErrorInvalidFormat;
+        case Loader::ResultStatus::ErrorUnsupportedArch:
+            return ResultStatus::ErrorUnsupportedArch;
+        default:
             return ResultStatus::ErrorSystemMode;
+        }
     }
 
     ResultStatus init_result{Init(emu_window)};
@@ -119,9 +129,17 @@ System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::st
         LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
         System::Shutdown();
 
-        if (load_result != Loader::ResultStatus::Success) {
-            return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
-                                             static_cast<u32>(load_result));
+        switch (load_result) {
+        case Loader::ResultStatus::ErrorMissingKeys:
+            return ResultStatus::ErrorLoader_ErrorMissingKeys;
+        case Loader::ResultStatus::ErrorDecrypting:
+            return ResultStatus::ErrorLoader_ErrorDecrypting;
+        case Loader::ResultStatus::ErrorInvalidFormat:
+            return ResultStatus::ErrorLoader_ErrorInvalidFormat;
+        case Loader::ResultStatus::ErrorUnsupportedArch:
+            return ResultStatus::ErrorUnsupportedArch;
+        default:
+            return ResultStatus::ErrorLoader;
         }
     }
     status = ResultStatus::Success;
@@ -151,7 +169,7 @@ Cpu& System::CpuCore(size_t core_index) {
     return *cpu_cores[core_index];
 }
 
-System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
+System::ResultStatus System::Init(EmuWindow& emu_window) {
     LOG_DEBUG(HW_Memory, "initialized OK");
 
     CoreTiming::Init();

src/core/core.h

@@ -22,11 +22,8 @@
 #include "video_core/debug_utils/debug_utils.h"
 #include "video_core/gpu.h"
 
-class ARM_Interface;
-
-namespace Core::Frontend {
 class EmuWindow;
-}
+class ARM_Interface;
 
 namespace Service::SM {
 class ServiceManager;
@@ -52,15 +49,21 @@ public:
 
     /// Enumeration representing the return values of the System Initialize and Load process.
     enum class ResultStatus : u32 {
-        Success,             ///< Succeeded
-        ErrorNotInitialized, ///< Error trying to use core prior to initialization
-        ErrorGetLoader,      ///< Error finding the correct application loader
-        ErrorSystemMode,     ///< Error determining the system mode
-        ErrorSystemFiles,    ///< Error in finding system files
-        ErrorSharedFont,     ///< Error in finding shared font
-        ErrorVideoCore,      ///< Error in the video core
-        ErrorUnknown,        ///< Any other error
-        ErrorLoader,         ///< The base for loader errors (too many to repeat)
+        Success,                      ///< Succeeded
+        ErrorNotInitialized,          ///< Error trying to use core prior to initialization
+        ErrorGetLoader,               ///< Error finding the correct application loader
+        ErrorSystemMode,              ///< Error determining the system mode
+        ErrorLoader,                  ///< Error loading the specified application
+        ErrorLoader_ErrorMissingKeys, ///< Error because the key/keys needed to run could not be
+                                      ///< found.
+        ErrorLoader_ErrorDecrypting,  ///< Error loading the specified application due to encryption
+        ErrorLoader_ErrorInvalidFormat, ///< Error loading the specified application due to an
+                                        /// invalid format
+        ErrorSystemFiles,               ///< Error in finding system files
+        ErrorSharedFont,                ///< Error in finding shared font
+        ErrorVideoCore,                 ///< Error in the video core
+        ErrorUnsupportedArch,           ///< Unsupported Architecture (32-Bit ROMs)
+        ErrorUnknown                    ///< Any other error
     };
 
     /**
@@ -102,7 +105,7 @@ public:
      * @param filepath String path to the executable application to load on the host file system.
      * @returns ResultStatus code, indicating if the operation succeeded.
      */
-    ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath);
+    ResultStatus Load(EmuWindow& emu_window, const std::string& filepath);
 
     /**
      * Indicates if the emulated system is powered on (all subsystems initialized and able to run an
@@ -230,7 +233,7 @@ private:
      *                   input.
      * @return ResultStatus code, indicating if the operation succeeded.
      */
-    ResultStatus Init(Frontend::EmuWindow& emu_window);
+    ResultStatus Init(EmuWindow& emu_window);
 
     /// RealVfsFilesystem instance
     FileSys::VirtualFilesystem virtual_filesystem;

src/core/core_cpu.cpp

@@ -14,7 +14,6 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/lock.h"
 #include "core/settings.h"
 
 namespace Core {
@@ -91,7 +90,6 @@ void Cpu::RunLoop(bool tight_loop) {
         LOG_TRACE(Core, "Core-{} idling", core_index);
 
         if (IsMainCore()) {
-            // TODO(Subv): Only let CoreTiming idle if all 4 cores are idling.
             CoreTiming::Idle();
             CoreTiming::Advance();
         }
@@ -127,8 +125,6 @@ void Cpu::Reschedule() {
     }
 
     reschedule_pending = false;
-    // Lock the global kernel mutex when we manipulate the HLE state
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
     scheduler->Reschedule();
 }
 

src/core/core_cpu.h

@@ -79,7 +79,7 @@ private:
     std::shared_ptr<CpuBarrier> cpu_barrier;
     std::shared_ptr<Kernel::Scheduler> scheduler;
 
-    std::atomic<bool> reschedule_pending = false;
+    bool reschedule_pending{};
     size_t core_index;
 };
 

src/core/core_timing.cpp

@@ -135,9 +135,11 @@ void ClearPendingEvents() {
 void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
     ASSERT(event_type != nullptr);
     s64 timeout = GetTicks() + cycles_into_future;
+
     // If this event needs to be scheduled before the next advance(), force one early
     if (!is_global_timer_sane)
         ForceExceptionCheck(cycles_into_future);
+
     event_queue.emplace_back(Event{timeout, event_fifo_id++, userdata, event_type});
     std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
 }

src/core/file_sys/card_image.cpp

@@ -12,16 +12,14 @@
 
 namespace FileSys {
 
-constexpr std::array<const char*, 0x4> partition_names = {"update", "normal", "secure", "logo"};
-
 XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
     if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
-        status = Loader::ResultStatus::ErrorBadXCIHeader;
+        status = Loader::ResultStatus::ErrorInvalidFormat;
         return;
     }
 
     if (header.magic != Common::MakeMagic('H', 'E', 'A', 'D')) {
-        status = Loader::ResultStatus::ErrorBadXCIHeader;
+        status = Loader::ResultStatus::ErrorInvalidFormat;
         return;
     }
 
@@ -33,6 +31,9 @@ XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
         return;
     }
 
+    static constexpr std::array<const char*, 0x4> partition_names = {"update", "normal", "secure",
+                                                                     "logo"};
+
     for (XCIPartition partition :
          {XCIPartition::Update, XCIPartition::Normal, XCIPartition::Secure, XCIPartition::Logo}) {
         auto raw = main_hfs.GetFile(partition_names[static_cast<size_t>(partition)]);
@@ -107,19 +108,19 @@ VirtualFile XCI::GetNCAFileByType(NCAContentType type) const {
     return nullptr;
 }
 
-std::vector<VirtualFile> XCI::GetFiles() const {
+std::vector<std::shared_ptr<VfsFile>> XCI::GetFiles() const {
     return {};
 }
 
-std::vector<VirtualDir> XCI::GetSubdirectories() const {
-    return {};
+std::vector<std::shared_ptr<VfsDirectory>> XCI::GetSubdirectories() const {
+    return std::vector<std::shared_ptr<VfsDirectory>>();
 }
 
 std::string XCI::GetName() const {
     return file->GetName();
 }
 
-VirtualDir XCI::GetParentDirectory() const {
+std::shared_ptr<VfsDirectory> XCI::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
@@ -129,21 +130,15 @@ bool XCI::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
 
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     if (partitions[static_cast<size_t>(part)] == nullptr) {
-        return Loader::ResultStatus::ErrorXCIMissingPartition;
+        return Loader::ResultStatus::ErrorInvalidFormat;
     }
 
     for (const VirtualFile& file : partitions[static_cast<size_t>(part)]->GetFiles()) {
         if (file->GetExtension() != "nca")
             continue;
         auto nca = std::make_shared<NCA>(file);
-        if (nca->GetStatus() == Loader::ResultStatus::Success) {
+        if (nca->GetStatus() == Loader::ResultStatus::Success)
             ncas.push_back(std::move(nca));
-        } else {
-            const u16 error_id = static_cast<u16>(nca->GetStatus());
-            LOG_CRITICAL(Loader, "Could not load NCA {}/{}, failed with error code {:04X} ({})",
-                         partition_names[static_cast<size_t>(part)], nca->GetName(), error_id,
-                         Loader::GetMessageForResultStatus(nca->GetStatus()));
-        }
     }
 
     return Loader::ResultStatus::Success;

src/core/file_sys/card_image.h

@@ -71,13 +71,13 @@ public:
     std::shared_ptr<NCA> GetNCAByType(NCAContentType type) const;
     VirtualFile GetNCAFileByType(NCAContentType type) const;
 
-    std::vector<VirtualFile> GetFiles() const override;
+    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
 
-    std::vector<VirtualDir> GetSubdirectories() const override;
+    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
 
     std::string GetName() const override;
 
-    VirtualDir GetParentDirectory() const override;
+    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
 
 protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;

src/core/file_sys/content_archive.cpp

@@ -113,27 +113,17 @@ boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType ty
     return out;
 }
 
-boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
+boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() const {
     const auto master_key_id = GetCryptoRevision();
 
     u128 rights_id{};
     memcpy(rights_id.data(), header.rights_id.data(), 16);
-    if (rights_id == u128{}) {
-        status = Loader::ResultStatus::ErrorInvalidRightsID;
+    if (rights_id == u128{})
         return boost::none;
-    }
 
     auto titlekey = keys.GetKey(Core::Crypto::S128KeyType::Titlekey, rights_id[1], rights_id[0]);
-    if (titlekey == Core::Crypto::Key128{}) {
-        status = Loader::ResultStatus::ErrorMissingTitlekey;
+    if (titlekey == Core::Crypto::Key128{})
         return boost::none;
-    }
-
-    if (!keys.HasKey(Core::Crypto::S128KeyType::Titlekek, master_key_id)) {
-        status = Loader::ResultStatus::ErrorMissingTitlekek;
-        return boost::none;
-    }
-
     Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
         keys.GetKey(Core::Crypto::S128KeyType::Titlekek, master_key_id), Core::Crypto::Mode::ECB);
     cipher.Transcode(titlekey.data(), titlekey.size(), titlekey.data(), Core::Crypto::Op::Decrypt);
@@ -141,7 +131,7 @@ boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
     return titlekey;
 }
 
-VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting_offset) {
+VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting_offset) const {
     if (!encrypted)
         return in;
 
@@ -153,22 +143,15 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
         LOG_DEBUG(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
         {
             boost::optional<Core::Crypto::Key128> key = boost::none;
-            if (has_rights_id) {
-                status = Loader::ResultStatus::Success;
-                key = GetTitlekey();
-                if (key == boost::none) {
-                    if (status == Loader::ResultStatus::Success)
-                        status = Loader::ResultStatus::ErrorMissingTitlekey;
-                    return nullptr;
-                }
-            } else {
+            if (std::find_if_not(header.rights_id.begin(), header.rights_id.end(),
+                                 [](char c) { return c == 0; }) == header.rights_id.end()) {
                 key = GetKeyAreaKey(NCASectionCryptoType::CTR);
-                if (key == boost::none) {
-                    status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
-                    return nullptr;
-                }
+            } else {
+                key = GetTitlekey();
             }
 
+            if (key == boost::none)
+                return nullptr;
             auto out = std::make_shared<Core::Crypto::CTREncryptionLayer>(
                 std::move(in), key.value(), starting_offset);
             std::vector<u8> iv(16);
@@ -187,31 +170,16 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
 }
 
 NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
-    status = Loader::ResultStatus::Success;
-
     if (file == nullptr) {
-        status = Loader::ResultStatus::ErrorNullFile;
+        status = Loader::ResultStatus::ErrorInvalidFormat;
         return;
     }
-
-    if (sizeof(NCAHeader) != file->ReadObject(&header)) {
+    if (sizeof(NCAHeader) != file->ReadObject(&header))
         LOG_ERROR(Loader, "File reader errored out during header read.");
-        status = Loader::ResultStatus::ErrorBadNCAHeader;
-        return;
-    }
 
     encrypted = false;
 
     if (!IsValidNCA(header)) {
-        if (header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
-            status = Loader::ResultStatus::ErrorNCA2;
-            return;
-        }
-        if (header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
-            status = Loader::ResultStatus::ErrorNCA0;
-            return;
-        }
-
         NCAHeader dec_header{};
         Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
             keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
@@ -221,26 +189,14 @@ NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
             header = dec_header;
             encrypted = true;
         } else {
-            if (dec_header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
-                status = Loader::ResultStatus::ErrorNCA2;
-                return;
-            }
-            if (dec_header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
-                status = Loader::ResultStatus::ErrorNCA0;
-                return;
-            }
-
             if (!keys.HasKey(Core::Crypto::S256KeyType::Header))
-                status = Loader::ResultStatus::ErrorMissingHeaderKey;
+                status = Loader::ResultStatus::ErrorMissingKeys;
             else
-                status = Loader::ResultStatus::ErrorIncorrectHeaderKey;
+                status = Loader::ResultStatus::ErrorDecrypting;
             return;
         }
     }
 
-    has_rights_id = std::find_if_not(header.rights_id.begin(), header.rights_id.end(),
-                                     [](char c) { return c == '\0'; }) != header.rights_id.end();
-
     const std::ptrdiff_t number_sections =
         std::count_if(std::begin(header.section_tables), std::end(header.section_tables),
                       [](NCASectionTableEntry entry) { return entry.media_offset > 0; });
@@ -273,12 +229,7 @@ NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
                 files.push_back(std::move(dec));
                 romfs = files.back();
             } else {
-                if (status != Loader::ResultStatus::Success)
-                    return;
-                if (has_rights_id)
-                    status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-                else
-                    status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+                status = Loader::ResultStatus::ErrorMissingKeys;
                 return;
             }
         } else if (section.raw.header.filesystem_type == NCASectionFilesystemType::PFS0) {
@@ -298,12 +249,7 @@ NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
                         exefs = dirs.back();
                 }
             } else {
-                if (status != Loader::ResultStatus::Success)
-                    return;
-                if (has_rights_id)
-                    status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-                else
-                    status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+                status = Loader::ResultStatus::ErrorMissingKeys;
                 return;
             }
         }

src/core/file_sys/content_archive.h

@@ -98,8 +98,8 @@ protected:
 private:
     u8 GetCryptoRevision() const;
     boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
-    boost::optional<Core::Crypto::Key128> GetTitlekey();
-    VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset);
+    boost::optional<Core::Crypto::Key128> GetTitlekey() const;
+    VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset) const;
 
     std::vector<VirtualDir> dirs;
     std::vector<VirtualFile> files;
@@ -109,7 +109,6 @@ private:
     VirtualFile file;
 
     NCAHeader header{};
-    bool has_rights_id{};
 
     Loader::ResultStatus status{};
 

src/core/file_sys/partition_filesystem.cpp

@@ -24,19 +24,19 @@ bool PartitionFilesystem::Header::HasValidMagicValue() const {
 PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
     // At least be as large as the header
     if (file->GetSize() < sizeof(Header)) {
-        status = Loader::ResultStatus::ErrorBadPFSHeader;
+        status = Loader::ResultStatus::Error;
         return;
     }
 
     // For cartridges, HFSs can get very large, so we need to calculate the size up to
     // the actual content itself instead of just blindly reading in the entire file.
     if (sizeof(Header) != file->ReadObject(&pfs_header)) {
-        status = Loader::ResultStatus::ErrorBadPFSHeader;
+        status = Loader::ResultStatus::Error;
         return;
     }
 
     if (!pfs_header.HasValidMagicValue()) {
-        status = Loader::ResultStatus::ErrorBadPFSHeader;
+        status = Loader::ResultStatus::ErrorInvalidFormat;
         return;
     }
 
@@ -51,7 +51,7 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
     const size_t total_size = file_data.size();
 
     if (total_size != metadata_size) {
-        status = Loader::ResultStatus::ErrorIncorrectPFSFileSize;
+        status = Loader::ResultStatus::Error;
         return;
     }
 

src/core/file_sys/partition_filesystem.h

@@ -13,7 +13,7 @@
 #include "core/file_sys/vfs.h"
 
 namespace Loader {
-enum class ResultStatus : u16;
+enum class ResultStatus;
 }
 
 namespace FileSys {

src/core/file_sys/program_metadata.cpp

@@ -12,26 +12,26 @@ namespace FileSys {
 Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
     size_t total_size = static_cast<size_t>(file->GetSize());
     if (total_size < sizeof(Header))
-        return Loader::ResultStatus::ErrorBadNPDMHeader;
+        return Loader::ResultStatus::Error;
 
     // TODO(DarkLordZach): Use ReadObject when Header/AcidHeader becomes trivially copyable.
     std::vector<u8> npdm_header_data = file->ReadBytes(sizeof(Header));
     if (sizeof(Header) != npdm_header_data.size())
-        return Loader::ResultStatus::ErrorBadNPDMHeader;
+        return Loader::ResultStatus::Error;
     std::memcpy(&npdm_header, npdm_header_data.data(), sizeof(Header));
 
     std::vector<u8> acid_header_data = file->ReadBytes(sizeof(AcidHeader), npdm_header.acid_offset);
     if (sizeof(AcidHeader) != acid_header_data.size())
-        return Loader::ResultStatus::ErrorBadACIDHeader;
+        return Loader::ResultStatus::Error;
     std::memcpy(&acid_header, acid_header_data.data(), sizeof(AcidHeader));
 
     if (sizeof(AciHeader) != file->ReadObject(&aci_header, npdm_header.aci_offset))
-        return Loader::ResultStatus::ErrorBadACIHeader;
+        return Loader::ResultStatus::Error;
 
     if (sizeof(FileAccessControl) != file->ReadObject(&acid_file_access, acid_header.fac_offset))
-        return Loader::ResultStatus::ErrorBadFileAccessControl;
+        return Loader::ResultStatus::Error;
     if (sizeof(FileAccessHeader) != file->ReadObject(&aci_file_access, aci_header.fah_offset))
-        return Loader::ResultStatus::ErrorBadFileAccessHeader;
+        return Loader::ResultStatus::Error;
 
     return Loader::ResultStatus::Success;
 }

src/core/file_sys/program_metadata.h

@@ -13,7 +13,7 @@
 #include "partition_filesystem.h"
 
 namespace Loader {
-enum class ResultStatus : u16;
+enum class ResultStatus;
 }
 
 namespace FileSys {

src/core/file_sys/vfs.cpp

@@ -74,15 +74,15 @@ VirtualFile VfsFilesystem::CopyFile(std::string_view old_path_, std::string_view
     return new_file;
 }
 
-VirtualFile VfsFilesystem::MoveFile(std::string_view old_path, std::string_view new_path) {
-    const auto sanitized_old_path = FileUtil::SanitizePath(old_path);
-    const auto sanitized_new_path = FileUtil::SanitizePath(new_path);
+VirtualFile VfsFilesystem::MoveFile(std::string_view old_path_, std::string_view new_path_) {
+    const auto old_path = FileUtil::SanitizePath(old_path_);
+    const auto new_path = FileUtil::SanitizePath(new_path_);
 
     // Again, non-default impls are highly encouraged to provide a more optimized version of this.
-    auto out = CopyFile(sanitized_old_path, sanitized_new_path);
+    auto out = CopyFile(old_path_, new_path_);
     if (out == nullptr)
         return nullptr;
-    if (DeleteFile(sanitized_old_path))
+    if (DeleteFile(old_path))
         return out;
     return nullptr;
 }
@@ -137,15 +137,15 @@ VirtualDir VfsFilesystem::CopyDirectory(std::string_view old_path_, std::string_
     return new_dir;
 }
 
-VirtualDir VfsFilesystem::MoveDirectory(std::string_view old_path, std::string_view new_path) {
-    const auto sanitized_old_path = FileUtil::SanitizePath(old_path);
-    const auto sanitized_new_path = FileUtil::SanitizePath(new_path);
+VirtualDir VfsFilesystem::MoveDirectory(std::string_view old_path_, std::string_view new_path_) {
+    const auto old_path = FileUtil::SanitizePath(old_path_);
+    const auto new_path = FileUtil::SanitizePath(new_path_);
 
     // Non-default impls are highly encouraged to provide a more optimized version of this.
-    auto out = CopyDirectory(sanitized_old_path, sanitized_new_path);
+    auto out = CopyDirectory(old_path_, new_path_);
     if (out == nullptr)
         return nullptr;
-    if (DeleteDirectory(sanitized_old_path))
+    if (DeleteDirectory(old_path))
         return out;
     return nullptr;
 }

src/core/file_sys/vfs.h

@@ -15,9 +15,9 @@
 
 namespace FileSys {
 
-class VfsDirectory;
-class VfsFile;
-class VfsFilesystem;
+struct VfsFilesystem;
+struct VfsFile;
+struct VfsDirectory;
 
 // Convenience typedefs to use Vfs* interfaces
 using VirtualFilesystem = std::shared_ptr<VfsFilesystem>;
@@ -34,9 +34,8 @@ enum class VfsEntryType {
 // A class representing an abstract filesystem. A default implementation given the root VirtualDir
 // is provided for convenience, but if the Vfs implementation has any additional state or
 // functionality, they will need to override.
-class VfsFilesystem : NonCopyable {
-public:
-    explicit VfsFilesystem(VirtualDir root);
+struct VfsFilesystem : NonCopyable {
+    VfsFilesystem(VirtualDir root);
     virtual ~VfsFilesystem();
 
     // Gets the friendly name for the filesystem.
@@ -82,8 +81,7 @@ protected:
 };
 
 // A class representing a file in an abstract filesystem.
-class VfsFile : NonCopyable {
-public:
+struct VfsFile : NonCopyable {
     virtual ~VfsFile();
 
     // Retrieves the file name.
@@ -181,8 +179,7 @@ public:
 };
 
 // A class representing a directory in an abstract filesystem.
-class VfsDirectory : NonCopyable {
-public:
+struct VfsDirectory : NonCopyable {
     virtual ~VfsDirectory();
 
     // Retrives the file located at path as if the current directory was root. Returns nullptr if
@@ -298,8 +295,7 @@ protected:
 
 // A convenience partial-implementation of VfsDirectory that stubs out methods that should only work
 // if writable. This is to avoid redundant empty methods everywhere.
-class ReadOnlyVfsDirectory : public VfsDirectory {
-public:
+struct ReadOnlyVfsDirectory : public VfsDirectory {
     bool IsWritable() const override;
     bool IsReadable() const override;
     std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;

src/core/file_sys/vfs_offset.h

@@ -15,8 +15,7 @@ namespace FileSys {
 // Similar to seeking to an offset.
 // If the file is writable, operations that would write past the end of the offset file will expand
 // the size of this wrapper.
-class OffsetVfsFile : public VfsFile {
-public:
+struct OffsetVfsFile : public VfsFile {
     OffsetVfsFile(std::shared_ptr<VfsFile> file, size_t size, size_t offset = 0,
                   std::string new_name = "", VirtualDir new_parent = nullptr);
 

src/core/file_sys/vfs_vector.h

@@ -10,8 +10,7 @@ namespace FileSys {
 
 // An implementation of VfsDirectory that maintains two vectors for subdirectories and files.
 // Vector data is supplied upon construction.
-class VectorVfsDirectory : public VfsDirectory {
-public:
+struct VectorVfsDirectory : public VfsDirectory {
     explicit VectorVfsDirectory(std::vector<VirtualFile> files = {},
                                 std::vector<VirtualDir> dirs = {}, VirtualDir parent = nullptr,
                                 std::string name = "");

src/core/frontend/emu_window.cpp

@@ -8,8 +8,6 @@
 #include "core/frontend/input.h"
 #include "core/settings.h"
 
-namespace Core::Frontend {
-
 class EmuWindow::TouchState : public Input::Factory<Input::TouchDevice>,
                               public std::enable_shared_from_this<TouchState> {
 public:
@@ -110,5 +108,3 @@ void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) {
 void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height) {
     NotifyFramebufferLayoutChanged(Layout::DefaultFrameLayout(width, height));
 }
-
-} // namespace Core::Frontend

src/core/frontend/emu_window.h

@@ -10,8 +10,6 @@
 #include "common/common_types.h"
 #include "core/frontend/framebuffer_layout.h"
 
-namespace Core::Frontend {
-
 /**
  * Abstraction class used to provide an interface between emulation code and the frontend
  * (e.g. SDL, QGLWidget, GLFW, etc...).
@@ -168,5 +166,3 @@ private:
      */
     std::tuple<unsigned, unsigned> ClipToTouchScreen(unsigned new_x, unsigned new_y);
 };
-
-} // namespace Core::Frontend

src/core/hle/kernel/kernel.cpp

@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-std::atomic<u32> Object::next_object_id{0};
+unsigned int Object::next_object_id;
 
 /// Initialize the kernel
 void Init() {

src/core/hle/kernel/object.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <atomic>
 #include <string>
 #include <utility>
 
@@ -43,8 +42,8 @@ public:
     virtual ~Object();
 
     /// Returns a unique identifier for the object. For debugging purposes only.
-    u32 GetObjectId() const {
-        return object_id.load(std::memory_order_relaxed);
+    unsigned int GetObjectId() const {
+        return object_id;
     }
 
     virtual std::string GetTypeName() const {
@@ -62,23 +61,23 @@ public:
     bool IsWaitable() const;
 
 public:
-    static std::atomic<u32> next_object_id;
+    static unsigned int next_object_id;
 
 private:
     friend void intrusive_ptr_add_ref(Object*);
     friend void intrusive_ptr_release(Object*);
 
-    std::atomic<u32> ref_count{0};
-    std::atomic<u32> object_id{next_object_id++};
+    unsigned int ref_count = 0;
+    unsigned int object_id = next_object_id++;
 };
 
 // Special functions used by boost::instrusive_ptr to do automatic ref-counting
 inline void intrusive_ptr_add_ref(Object* object) {
-    object->ref_count.fetch_add(1, std::memory_order_relaxed);
+    ++object->ref_count;
 }
 
 inline void intrusive_ptr_release(Object* object) {
-    if (object->ref_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+    if (--object->ref_count == 0) {
         delete object;
     }
 }

src/core/hle/kernel/scheduler.cpp

@@ -25,7 +25,7 @@ Scheduler::~Scheduler() {
     }
 }
 
-bool Scheduler::HaveReadyThreads() const {
+bool Scheduler::HaveReadyThreads() {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
     return ready_queue.get_first() != nullptr;
 }

src/core/hle/kernel/scheduler.h

@@ -21,7 +21,7 @@ public:
     ~Scheduler();
 
     /// Returns whether there are any threads that are ready to run.
-    bool HaveReadyThreads() const;
+    bool HaveReadyThreads();
 
     /// Reschedules to the next available thread (call after current thread is suspended)
     void Reschedule();

src/core/hle/kernel/server_session.cpp

@@ -71,14 +71,6 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
         const u32 object_id{context.GetDomainMessageHeader()->object_id};
         switch (domain_message_header->command) {
         case IPC::DomainMessageHeader::CommandType::SendMessage:
-            if (object_id > domain_request_handlers.size()) {
-                LOG_CRITICAL(IPC,
-                             "object_id {} is too big! This probably means a recent service call "
-                             "to {} needed to return a new interface!",
-                             object_id, name);
-                UNREACHABLE();
-                return RESULT_SUCCESS; // Ignore error if asserts are off
-            }
             return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
 
         case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {

src/core/hle/kernel/svc.cpp

@@ -532,6 +532,7 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
     CASCADE_RESULT(thread->guest_handle, g_handle_table.Create(thread));
     *out_handle = thread->guest_handle;
 
+    Core::System::GetInstance().PrepareReschedule();
     Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
 
     LOG_TRACE(Kernel_SVC,
@@ -705,7 +706,8 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
             Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
             auto owner = g_handle_table.Get<Thread>(owner_handle);
             ASSERT(owner);
-            ASSERT(thread->status == ThreadStatus::WaitMutex);
+            ASSERT(thread->status != ThreadStatus::Running);
+            thread->status = ThreadStatus::WaitMutex;
             thread->wakeup_callback = nullptr;
 
             owner->AddMutexWaiter(thread);

src/core/hle/kernel/thread.cpp

@@ -23,7 +23,6 @@
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/lock.h"
 #include "core/hle/result.h"
 #include "core/memory.h"
 
@@ -105,10 +104,6 @@ void ExitCurrentThread() {
  */
 static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
     const auto proper_handle = static_cast<Handle>(thread_handle);
-
-    // Lock the global kernel mutex when we enter the kernel HLE.
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
-
     SharedPtr<Thread> thread = wakeup_callback_handle_table.Get<Thread>(proper_handle);
     if (thread == nullptr) {
         LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
@@ -160,10 +155,8 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
     if (nanoseconds == -1)
         return;
 
-    // This function might be called from any thread so we have to be cautious and use the
-    // thread-safe version of ScheduleEvent.
-    CoreTiming::ScheduleEventThreadsafe(CoreTiming::nsToCycles(nanoseconds), ThreadWakeupEventType,
-                                        callback_handle);
+    CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(nanoseconds), ThreadWakeupEventType,
+                              callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {
@@ -426,33 +419,12 @@ VAddr Thread::GetCommandBufferAddress() const {
 }
 
 void Thread::AddMutexWaiter(SharedPtr<Thread> thread) {
-    if (thread->lock_owner == this) {
-        // If the thread is already waiting for this thread to release the mutex, ensure that the
-        // waiters list is consistent and return without doing anything.
-        auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
-        ASSERT(itr != wait_mutex_threads.end());
-        return;
-    }
-
-    // A thread can't wait on two different mutexes at the same time.
-    ASSERT(thread->lock_owner == nullptr);
-
-    // Ensure that the thread is not already in the list of mutex waiters
-    auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
-    ASSERT(itr == wait_mutex_threads.end());
-
     thread->lock_owner = this;
     wait_mutex_threads.emplace_back(std::move(thread));
     UpdatePriority();
 }
 
 void Thread::RemoveMutexWaiter(SharedPtr<Thread> thread) {
-    ASSERT(thread->lock_owner == this);
-
-    // Ensure that the thread is in the list of mutex waiters
-    auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
-    ASSERT(itr != wait_mutex_threads.end());
-
     boost::remove_erase(wait_mutex_threads, thread);
     thread->lock_owner = nullptr;
     UpdatePriority();

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

@@ -145,8 +145,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {51, nullptr, "ApproveToDisplay"},
         {60, nullptr, "OverrideAutoSleepTimeAndDimmingTime"},
         {61, nullptr, "SetMediaPlaybackState"},
-        {62, &ISelfController::SetIdleTimeDetectionExtension, "SetIdleTimeDetectionExtension"},
-        {63, &ISelfController::GetIdleTimeDetectionExtension, "GetIdleTimeDetectionExtension"},
+        {62, nullptr, "SetIdleTimeDetectionExtension"},
+        {63, nullptr, "GetIdleTimeDetectionExtension"},
         {64, nullptr, "SetInputDetectionSourceSet"},
         {65, nullptr, "ReportUserIsActive"},
         {66, nullptr, "GetCurrentIlluminance"},
@@ -281,23 +281,6 @@ void ISelfController::SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx)
     LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 
-void ISelfController::SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    idle_time_detection_extension = rp.Pop<u32>();
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(idle_time_detection_extension);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
 ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter") {
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},

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

@@ -87,12 +87,9 @@ private:
     void CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx);
     void SetScreenShotPermission(Kernel::HLERequestContext& ctx);
     void SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx);
-    void SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
-    void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     Kernel::SharedPtr<Kernel::Event> launchable_event;
-    u32 idle_time_detection_extension = 0;
 };
 
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {

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

@@ -20,9 +20,9 @@ public:
     explicit IAudioRenderer(AudioCore::AudioRendererParameter audren_params)
         : ServiceFramework("IAudioRenderer") {
         static const FunctionInfo functions[] = {
-            {0, &IAudioRenderer::GetAudioRendererSampleRate, "GetAudioRendererSampleRate"},
-            {1, &IAudioRenderer::GetAudioRendererSampleCount, "GetAudioRendererSampleCount"},
-            {2, &IAudioRenderer::GetAudioRendererMixBufferCount, "GetAudioRendererMixBufferCount"},
+            {0, nullptr, "GetAudioRendererSampleRate"},
+            {1, nullptr, "GetAudioRendererSampleCount"},
+            {2, nullptr, "GetAudioRendererMixBufferCount"},
             {3, nullptr, "GetAudioRendererState"},
             {4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
             {5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
@@ -45,27 +45,6 @@ private:
         system_event->Signal();
     }
 
-    void GetAudioRendererSampleRate(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(renderer->GetSampleRate());
-        LOG_DEBUG(Service_Audio, "called");
-    }
-
-    void GetAudioRendererSampleCount(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(renderer->GetSampleCount());
-        LOG_DEBUG(Service_Audio, "called");
-    }
-
-    void GetAudioRendererMixBufferCount(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(renderer->GetMixBufferCount());
-        LOG_DEBUG(Service_Audio, "called");
-    }
-
     void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
         ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
         IPC::ResponseBuilder rb{ctx, 2};
@@ -190,8 +169,7 @@ AudRenU::AudRenU() : ServiceFramework("audren:u") {
         {1, &AudRenU::GetAudioRendererWorkBufferSize, "GetAudioRendererWorkBufferSize"},
         {2, &AudRenU::GetAudioDevice, "GetAudioDevice"},
         {3, nullptr, "OpenAudioRendererAuto"},
-        {4, &AudRenU::GetAudioDeviceServiceWithRevisionInfo,
-         "GetAudioDeviceServiceWithRevisionInfo"},
+        {4, nullptr, "GetAudioDeviceServiceWithRevisionInfo"},
     };
     RegisterHandlers(functions);
 }
@@ -211,7 +189,7 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     auto params = rp.PopRaw<AudioCore::AudioRendererParameter>();
 
-    u64 buffer_sz = Common::AlignUp(4 * params.mix_buffer_count, 0x40);
+    u64 buffer_sz = Common::AlignUp(4 * params.unknown_8, 0x40);
     buffer_sz += params.unknown_c * 1024;
     buffer_sz += 0x940 * (params.unknown_c + 1);
     buffer_sz += 0x3F0 * params.voice_count;
@@ -219,7 +197,7 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
     buffer_sz += Common::AlignUp(8 * params.voice_count, 0x10);
     buffer_sz +=
         Common::AlignUp((0x3C0 * (params.sink_count + params.unknown_c) + 4 * params.sample_count) *
-                            (params.mix_buffer_count + 6),
+                            (params.unknown_8 + 6),
                         0x40);
 
     if (IsFeatureSupported(AudioFeatures::Splitter, params.revision)) {
@@ -275,16 +253,6 @@ void AudRenU::GetAudioDevice(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Audio, "called");
 }
 
-void AudRenU::GetAudioDeviceServiceWithRevisionInfo(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<Audio::IAudioDevice>();
-
-    LOG_WARNING(Service_Audio, "(STUBBED) called"); // TODO(ogniK): Figure out what is different
-                                                    // based on the current revision
-}
-
 bool AudRenU::IsFeatureSupported(AudioFeatures feature, u32_le revision) const {
     u32_be version_num = (revision - Common::MakeMagic('R', 'E', 'V', '0')); // Byte swap
     switch (feature) {

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

@@ -22,7 +22,6 @@ private:
     void OpenAudioRenderer(Kernel::HLERequestContext& ctx);
     void GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx);
     void GetAudioDevice(Kernel::HLERequestContext& ctx);
-    void GetAudioDeviceServiceWithRevisionInfo(Kernel::HLERequestContext& ctx);
 
     enum class AudioFeatures : u32 {
         Splitter,

src/core/hle/service/friend/friend.cpp

@@ -9,110 +9,10 @@
 
 namespace Service::Friend {
 
-class IFriendService final : public ServiceFramework<IFriendService> {
-public:
-    IFriendService() : ServiceFramework("IFriendService") {
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetCompletionEvent"},
-            {1, nullptr, "Cancel"},
-            {10100, nullptr, "GetFriendListIds"},
-            {10101, nullptr, "GetFriendList"},
-            {10102, nullptr, "UpdateFriendInfo"},
-            {10110, nullptr, "GetFriendProfileImage"},
-            {10200, nullptr, "SendFriendRequestForApplication"},
-            {10211, nullptr, "AddFacedFriendRequestForApplication"},
-            {10400, nullptr, "GetBlockedUserListIds"},
-            {10500, nullptr, "GetProfileList"},
-            {10600, nullptr, "DeclareOpenOnlinePlaySession"},
-            {10601, &IFriendService::DeclareCloseOnlinePlaySession,
-             "DeclareCloseOnlinePlaySession"},
-            {10610, &IFriendService::UpdateUserPresence, "UpdateUserPresence"},
-            {10700, nullptr, "GetPlayHistoryRegistrationKey"},
-            {10701, nullptr, "GetPlayHistoryRegistrationKeyWithNetworkServiceAccountId"},
-            {10702, nullptr, "AddPlayHistory"},
-            {11000, nullptr, "GetProfileImageUrl"},
-            {20100, nullptr, "GetFriendCount"},
-            {20101, nullptr, "GetNewlyFriendCount"},
-            {20102, nullptr, "GetFriendDetailedInfo"},
-            {20103, nullptr, "SyncFriendList"},
-            {20104, nullptr, "RequestSyncFriendList"},
-            {20110, nullptr, "LoadFriendSetting"},
-            {20200, nullptr, "GetReceivedFriendRequestCount"},
-            {20201, nullptr, "GetFriendRequestList"},
-            {20300, nullptr, "GetFriendCandidateList"},
-            {20301, nullptr, "GetNintendoNetworkIdInfo"},
-            {20302, nullptr, "GetSnsAccountLinkage"},
-            {20303, nullptr, "GetSnsAccountProfile"},
-            {20304, nullptr, "GetSnsAccountFriendList"},
-            {20400, nullptr, "GetBlockedUserList"},
-            {20401, nullptr, "SyncBlockedUserList"},
-            {20500, nullptr, "GetProfileExtraList"},
-            {20501, nullptr, "GetRelationship"},
-            {20600, nullptr, "GetUserPresenceView"},
-            {20700, nullptr, "GetPlayHistoryList"},
-            {20701, nullptr, "GetPlayHistoryStatistics"},
-            {20800, nullptr, "LoadUserSetting"},
-            {20801, nullptr, "SyncUserSetting"},
-            {20900, nullptr, "RequestListSummaryOverlayNotification"},
-            {21000, nullptr, "GetExternalApplicationCatalog"},
-            {30100, nullptr, "DropFriendNewlyFlags"},
-            {30101, nullptr, "DeleteFriend"},
-            {30110, nullptr, "DropFriendNewlyFlag"},
-            {30120, nullptr, "ChangeFriendFavoriteFlag"},
-            {30121, nullptr, "ChangeFriendOnlineNotificationFlag"},
-            {30200, nullptr, "SendFriendRequest"},
-            {30201, nullptr, "SendFriendRequestWithApplicationInfo"},
-            {30202, nullptr, "CancelFriendRequest"},
-            {30203, nullptr, "AcceptFriendRequest"},
-            {30204, nullptr, "RejectFriendRequest"},
-            {30205, nullptr, "ReadFriendRequest"},
-            {30210, nullptr, "GetFacedFriendRequestRegistrationKey"},
-            {30211, nullptr, "AddFacedFriendRequest"},
-            {30212, nullptr, "CancelFacedFriendRequest"},
-            {30213, nullptr, "GetFacedFriendRequestProfileImage"},
-            {30214, nullptr, "GetFacedFriendRequestProfileImageFromPath"},
-            {30215, nullptr, "SendFriendRequestWithExternalApplicationCatalogId"},
-            {30216, nullptr, "ResendFacedFriendRequest"},
-            {30217, nullptr, "SendFriendRequestWithNintendoNetworkIdInfo"},
-            {30300, nullptr, "GetSnsAccountLinkPageUrl"},
-            {30301, nullptr, "UnlinkSnsAccount"},
-            {30400, nullptr, "BlockUser"},
-            {30401, nullptr, "BlockUserWithApplicationInfo"},
-            {30402, nullptr, "UnblockUser"},
-            {30500, nullptr, "GetProfileExtraFromFriendCode"},
-            {30700, nullptr, "DeletePlayHistory"},
-            {30810, nullptr, "ChangePresencePermission"},
-            {30811, nullptr, "ChangeFriendRequestReception"},
-            {30812, nullptr, "ChangePlayLogPermission"},
-            {30820, nullptr, "IssueFriendCode"},
-            {30830, nullptr, "ClearPlayLog"},
-            {49900, nullptr, "DeleteNetworkServiceAccountCache"},
-        };
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void DeclareCloseOnlinePlaySession(Kernel::HLERequestContext& ctx) {
-        // Stub used by Splatoon 2
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void UpdateUserPresence(Kernel::HLERequestContext& ctx) {
-        // Stub used by Retro City Rampage
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-};
-
 void Module::Interface::CreateFriendService(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IFriendService>();
-    LOG_DEBUG(Service_ACC, "called");
+    LOG_WARNING(Service_Friend, "(STUBBED) called");
 }
 
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)

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

@@ -291,7 +291,6 @@ private:
 class Hid final : public ServiceFramework<Hid> {
 public:
     Hid() : ServiceFramework("hid") {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &Hid::CreateAppletResource, "CreateAppletResource"},
             {1, &Hid::ActivateDebugPad, "ActivateDebugPad"},
@@ -334,13 +333,15 @@ public:
             {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
             {103, &Hid::ActivateNpad, "ActivateNpad"},
             {104, nullptr, "DeactivateNpad"},
-            {106, &Hid::AcquireNpadStyleSetUpdateEventHandle, "AcquireNpadStyleSetUpdateEventHandle"},
-            {107, &Hid::DisconnectNpad, "DisconnectNpad"},
+            {106, &Hid::AcquireNpadStyleSetUpdateEventHandle,
+             "AcquireNpadStyleSetUpdateEventHandle"},
+            {107, nullptr, "DisconnectNpad"},
             {108, &Hid::GetPlayerLedPattern, "GetPlayerLedPattern"},
             {109, nullptr, "ActivateNpadWithRevision"},
             {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
             {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
-            {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault, "SetNpadJoyAssignmentModeSingleByDefault"},
+            {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault,
+             "SetNpadJoyAssignmentModeSingleByDefault"},
             {123, nullptr, "SetNpadJoyAssignmentModeSingleByDefault"},
             {124, &Hid::SetNpadJoyAssignmentModeDual, "SetNpadJoyAssignmentModeDual"},
             {125, &Hid::MergeSingleJoyAsDualJoy, "MergeSingleJoyAsDualJoy"},
@@ -397,8 +398,6 @@ public:
             {1000, nullptr, "SetNpadCommunicationMode"},
             {1001, nullptr, "GetNpadCommunicationMode"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
 
         event = Kernel::Event::Create(Kernel::ResetType::OneShot, "hid:EventHandle");
@@ -497,12 +496,6 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
-    void DisconnectNpad(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
     void GetPlayerLedPattern(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);

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

@@ -1,34 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/hle/service/nvdrv/devices/nvhost_nvjpg.h"
-
-namespace Service::Nvidia::Devices {
-
-u32 nvhost_nvjpg::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
-              command.raw, input.size(), output.size());
-
-    switch (static_cast<IoctlCommand>(command.raw)) {
-    case IoctlCommand::IocSetNVMAPfdCommand:
-        return SetNVMAPfd(input, output);
-    }
-
-    UNIMPLEMENTED_MSG("Unimplemented ioctl");
-    return 0;
-}
-
-u32 nvhost_nvjpg::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlSetNvmapFD params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
-    nvmap_fd = params.nvmap_fd;
-    return 0;
-}
-
-} // namespace Service::Nvidia::Devices

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

@@ -1,36 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/nvdrv/devices/nvdevice.h"
-
-namespace Service::Nvidia::Devices {
-
-class nvhost_nvjpg final : public nvdevice {
-public:
-    nvhost_nvjpg() = default;
-    ~nvhost_nvjpg() override = default;
-
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-
-private:
-    enum class IoctlCommand : u32_le {
-        IocSetNVMAPfdCommand = 0x40044801,
-    };
-
-    struct IoctlSetNvmapFD {
-        u32_le nvmap_fd;
-    };
-    static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
-
-    u32_le nvmap_fd{};
-
-    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
-};
-
-} // namespace Service::Nvidia::Devices

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

@@ -1,34 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/hle/service/nvdrv/devices/nvhost_vic.h"
-
-namespace Service::Nvidia::Devices {
-
-u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
-              command.raw, input.size(), output.size());
-
-    switch (static_cast<IoctlCommand>(command.raw)) {
-    case IoctlCommand::IocSetNVMAPfdCommand:
-        return SetNVMAPfd(input, output);
-    }
-
-    UNIMPLEMENTED_MSG("Unimplemented ioctl");
-    return 0;
-}
-
-u32 nvhost_vic::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlSetNvmapFD params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
-    nvmap_fd = params.nvmap_fd;
-    return 0;
-}
-
-} // namespace Service::Nvidia::Devices

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

@@ -1,36 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/nvdrv/devices/nvdevice.h"
-
-namespace Service::Nvidia::Devices {
-
-class nvhost_vic final : public nvdevice {
-public:
-    nvhost_vic() = default;
-    ~nvhost_vic() override = default;
-
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-
-private:
-    enum class IoctlCommand : u32_le {
-        IocSetNVMAPfdCommand = 0x40044801,
-    };
-
-    struct IoctlSetNvmapFD {
-        u32_le nvmap_fd;
-    };
-    static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
-
-    u32_le nvmap_fd{};
-
-    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
-};
-
-} // namespace Service::Nvidia::Devices

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

@@ -12,8 +12,6 @@
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
-#include "core/hle/service/nvdrv/devices/nvhost_nvjpg.h"
-#include "core/hle/service/nvdrv/devices/nvhost_vic.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
 #include "core/hle/service/nvdrv/interface.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
@@ -41,8 +39,6 @@ Module::Module() {
     devices["/dev/nvdisp_disp0"] = std::make_shared<Devices::nvdisp_disp0>(nvmap_dev);
     devices["/dev/nvhost-ctrl"] = std::make_shared<Devices::nvhost_ctrl>();
     devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>();
-    devices["/dev/nvhost-nvjpg"] = std::make_shared<Devices::nvhost_nvjpg>();
-    devices["/dev/nvhost-vic"] = std::make_shared<Devices::nvhost_vic>();
 }
 
 u32 Module::Open(const std::string& device_name) {

src/core/hle/service/nvflinger/buffer_queue.h

@@ -6,7 +6,6 @@
 
 #include <vector>
 #include <boost/optional.hpp>
-#include "common/common_funcs.h"
 #include "common/math_util.h"
 #include "common/swap.h"
 #include "core/hle/kernel/event.h"

src/core/hle/service/service.h

@@ -23,7 +23,7 @@ class HLERequestContext;
 } // namespace Kernel
 
 namespace FileSys {
-class VfsFilesystem;
+struct VfsFilesystem;
 }
 
 namespace Service {

src/core/loader/deconstructed_rom_directory.cpp

@@ -83,13 +83,13 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
 
     if (dir == nullptr) {
         if (file == nullptr)
-            return ResultStatus::ErrorNullFile;
+            return ResultStatus::ErrorInvalidFormat;
         dir = file->GetContainingDirectory();
     }
 
     const FileSys::VirtualFile npdm = dir->GetFile("main.npdm");
     if (npdm == nullptr)
-        return ResultStatus::ErrorMissingNPDM;
+        return ResultStatus::ErrorInvalidFormat;
 
     ResultStatus result = metadata.Load(npdm);
     if (result != ResultStatus::Success) {
@@ -99,7 +99,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
 
     const FileSys::ProgramAddressSpaceType arch_bits{metadata.GetAddressSpaceType()};
     if (arch_bits == FileSys::ProgramAddressSpaceType::Is32Bit) {
-        return ResultStatus::Error32BitISA;
+        return ResultStatus::ErrorUnsupportedArch;
     }
 
     // Load NSO modules
@@ -143,28 +143,28 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
 
 ResultStatus AppLoader_DeconstructedRomDirectory::ReadRomFS(FileSys::VirtualFile& dir) {
     if (romfs == nullptr)
-        return ResultStatus::ErrorNoRomFS;
+        return ResultStatus::ErrorNotUsed;
     dir = romfs;
     return ResultStatus::Success;
 }
 
 ResultStatus AppLoader_DeconstructedRomDirectory::ReadIcon(std::vector<u8>& buffer) {
     if (icon_data.empty())
-        return ResultStatus::ErrorNoIcon;
+        return ResultStatus::ErrorNotUsed;
     buffer = icon_data;
     return ResultStatus::Success;
 }
 
 ResultStatus AppLoader_DeconstructedRomDirectory::ReadProgramId(u64& out_program_id) {
     if (name.empty())
-        return ResultStatus::ErrorNoControl;
+        return ResultStatus::ErrorNotUsed;
     out_program_id = title_id;
     return ResultStatus::Success;
 }
 
 ResultStatus AppLoader_DeconstructedRomDirectory::ReadTitle(std::string& title) {
     if (name.empty())
-        return ResultStatus::ErrorNoControl;
+        return ResultStatus::ErrorNotUsed;
     title = name;
     return ResultStatus::Success;
 }

src/core/loader/elf.cpp

@@ -390,7 +390,7 @@ ResultStatus AppLoader_ELF::Load(Kernel::SharedPtr<Kernel::Process>& process) {
 
     std::vector<u8> buffer = file->ReadAllBytes();
     if (buffer.size() != file->GetSize())
-        return ResultStatus::ErrorIncorrectELFFileSize;
+        return ResultStatus::Error;
 
     ElfReader elf_reader(&buffer[0]);
     SharedPtr<CodeSet> codeset = elf_reader.LoadInto(Memory::PROCESS_IMAGE_VADDR);

src/core/loader/loader.cpp

@@ -86,55 +86,6 @@ std::string GetFileTypeString(FileType type) {
     return "unknown";
 }
 
-constexpr std::array<const char*, 36> RESULT_MESSAGES{
-    "The operation completed successfully.",
-    "The loader requested to load is already loaded.",
-    "The operation is not implemented.",
-    "The loader is not initialized properly.",
-    "The NPDM file has a bad header.",
-    "The NPDM has a bad ACID header.",
-    "The NPDM has a bad ACI header,",
-    "The NPDM file has a bad file access control.",
-    "The NPDM has a bad file access header.",
-    "The PFS/HFS partition has a bad header.",
-    "The PFS/HFS partition has incorrect size as determined by the header.",
-    "The NCA file has a bad header.",
-    "The general keyfile could not be found.",
-    "The NCA Header key could not be found.",
-    "The NCA Header key is incorrect or the header is invalid.",
-    "Support for NCA2-type NCAs is not implemented.",
-    "Support for NCA0-type NCAs is not implemented.",
-    "The titlekey for this Rights ID could not be found.",
-    "The titlekek for this crypto revision could not be found.",
-    "The Rights ID in the header is invalid.",
-    "The key area key for this application type and crypto revision could not be found.",
-    "The key area key is incorrect or the section header is invalid.",
-    "The titlekey and/or titlekek is incorrect or the section header is invalid.",
-    "The XCI file is missing a Program-type NCA.",
-    "The NCA file is not an application.",
-    "The ExeFS partition could not be found.",
-    "The XCI file has a bad header.",
-    "The XCI file is missing a partition.",
-    "The file could not be found or does not exist.",
-    "The game is missing a program metadata file (main.npdm).",
-    "The game uses the currently-unimplemented 32-bit architecture.",
-    "The RomFS could not be found.",
-    "The ELF file has incorrect size as determined by the header.",
-    "There was a general error loading the NRO into emulated memory.",
-    "There is no icon available.",
-    "There is no control data available.",
-};
-
-std::string GetMessageForResultStatus(ResultStatus status) {
-    return GetMessageForResultStatus(static_cast<u16>(status));
-}
-
-std::string GetMessageForResultStatus(u16 status) {
-    if (status >= 36)
-        return "";
-    return RESULT_MESSAGES[status];
-}
-
 /**
  * Get a loader for a file with a specific type
  * @param file The file to load

src/core/loader/loader.h

@@ -56,48 +56,20 @@ FileType GuessFromFilename(const std::string& name);
 std::string GetFileTypeString(FileType type);
 
 /// Return type for functions in Loader namespace
-enum class ResultStatus : u16 {
+enum class ResultStatus {
     Success,
-    ErrorAlreadyLoaded,
+    Error,
+    ErrorInvalidFormat,
     ErrorNotImplemented,
-    ErrorNotInitialized,
-    ErrorBadNPDMHeader,
-    ErrorBadACIDHeader,
-    ErrorBadACIHeader,
-    ErrorBadFileAccessControl,
-    ErrorBadFileAccessHeader,
-    ErrorBadPFSHeader,
-    ErrorIncorrectPFSFileSize,
-    ErrorBadNCAHeader,
-    ErrorMissingProductionKeyFile,
-    ErrorMissingHeaderKey,
-    ErrorIncorrectHeaderKey,
-    ErrorNCA2,
-    ErrorNCA0,
-    ErrorMissingTitlekey,
-    ErrorMissingTitlekek,
-    ErrorInvalidRightsID,
-    ErrorMissingKeyAreaKey,
-    ErrorIncorrectKeyAreaKey,
-    ErrorIncorrectTitlekeyOrTitlekek,
-    ErrorXCIMissingProgramNCA,
-    ErrorNCANotProgram,
-    ErrorNoExeFS,
-    ErrorBadXCIHeader,
-    ErrorXCIMissingPartition,
-    ErrorNullFile,
-    ErrorMissingNPDM,
-    Error32BitISA,
-    ErrorNoRomFS,
-    ErrorIncorrectELFFileSize,
-    ErrorLoadingNRO,
-    ErrorNoIcon,
-    ErrorNoControl,
+    ErrorNotLoaded,
+    ErrorNotUsed,
+    ErrorAlreadyLoaded,
+    ErrorMemoryAllocationFailed,
+    ErrorMissingKeys,
+    ErrorDecrypting,
+    ErrorUnsupportedArch,
 };
 
-std::string GetMessageForResultStatus(ResultStatus status);
-std::string GetMessageForResultStatus(u16 status);
-
 /// Interface for loading an application
 class AppLoader : NonCopyable {
 public:

src/core/loader/nca.cpp

@@ -46,12 +46,12 @@ ResultStatus AppLoader_NCA::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     }
 
     if (nca->GetType() != FileSys::NCAContentType::Program)
-        return ResultStatus::ErrorNCANotProgram;
+        return ResultStatus::ErrorInvalidFormat;
 
     const auto exefs = nca->GetExeFS();
 
     if (exefs == nullptr)
-        return ResultStatus::ErrorNoExeFS;
+        return ResultStatus::ErrorInvalidFormat;
 
     directory_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(exefs);
 
@@ -69,16 +69,16 @@ ResultStatus AppLoader_NCA::Load(Kernel::SharedPtr<Kernel::Process>& process) {
 
 ResultStatus AppLoader_NCA::ReadRomFS(FileSys::VirtualFile& dir) {
     if (nca == nullptr)
-        return ResultStatus::ErrorNotInitialized;
+        return ResultStatus::ErrorNotLoaded;
     if (nca->GetRomFS() == nullptr || nca->GetRomFS()->GetSize() == 0)
-        return ResultStatus::ErrorNoRomFS;
+        return ResultStatus::ErrorNotUsed;
     dir = nca->GetRomFS();
     return ResultStatus::Success;
 }
 
 ResultStatus AppLoader_NCA::ReadProgramId(u64& out_program_id) {
     if (nca == nullptr || nca->GetStatus() != ResultStatus::Success)
-        return ResultStatus::ErrorNotInitialized;
+        return ResultStatus::ErrorInvalidFormat;
     out_program_id = nca->GetTitleId();
     return ResultStatus::Success;
 }

src/core/loader/nro.cpp

@@ -182,7 +182,7 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     static constexpr VAddr base_addr{Memory::PROCESS_IMAGE_VADDR};
 
     if (!LoadNro(file, base_addr)) {
-        return ResultStatus::ErrorLoadingNRO;
+        return ResultStatus::ErrorInvalidFormat;
     }
 
     process->svc_access_mask.set();
@@ -197,7 +197,7 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
 
 ResultStatus AppLoader_NRO::ReadIcon(std::vector<u8>& buffer) {
     if (icon_data.empty()) {
-        return ResultStatus::ErrorNoIcon;
+        return ResultStatus::ErrorNotUsed;
     }
 
     buffer = icon_data;
@@ -206,7 +206,7 @@ ResultStatus AppLoader_NRO::ReadIcon(std::vector<u8>& buffer) {
 
 ResultStatus AppLoader_NRO::ReadProgramId(u64& out_program_id) {
     if (nacp == nullptr) {
-        return ResultStatus::ErrorNoControl;
+        return ResultStatus::ErrorNotUsed;
     }
 
     out_program_id = nacp->GetTitleId();
@@ -215,7 +215,7 @@ ResultStatus AppLoader_NRO::ReadProgramId(u64& out_program_id) {
 
 ResultStatus AppLoader_NRO::ReadRomFS(FileSys::VirtualFile& dir) {
     if (romfs == nullptr) {
-        return ResultStatus::ErrorNoRomFS;
+        return ResultStatus::ErrorNotUsed;
     }
 
     dir = romfs;
@@ -224,7 +224,7 @@ ResultStatus AppLoader_NRO::ReadRomFS(FileSys::VirtualFile& dir) {
 
 ResultStatus AppLoader_NRO::ReadTitle(std::string& title) {
     if (nacp == nullptr) {
-        return ResultStatus::ErrorNoControl;
+        return ResultStatus::ErrorNotUsed;
     }
 
     title = nacp->GetApplicationName();

src/core/loader/xci.cpp

@@ -66,13 +66,10 @@ ResultStatus AppLoader_XCI::Load(Kernel::SharedPtr<Kernel::Process>& process) {
         return ResultStatus::ErrorAlreadyLoaded;
     }
 
-    if (xci->GetStatus() != ResultStatus::Success)
-        return xci->GetStatus();
-
     if (xci->GetNCAFileByType(FileSys::NCAContentType::Program) == nullptr) {
         if (!Core::Crypto::KeyManager::KeyFileExists(false))
-            return ResultStatus::ErrorMissingProductionKeyFile;
-        return ResultStatus::ErrorXCIMissingProgramNCA;
+            return ResultStatus::ErrorMissingKeys;
+        return ResultStatus::ErrorDecrypting;
     }
 
     auto result = nca_loader->Load(process);
@@ -94,14 +91,14 @@ ResultStatus AppLoader_XCI::ReadProgramId(u64& out_program_id) {
 
 ResultStatus AppLoader_XCI::ReadIcon(std::vector<u8>& buffer) {
     if (icon_file == nullptr)
-        return ResultStatus::ErrorNoControl;
+        return ResultStatus::ErrorInvalidFormat;
     buffer = icon_file->ReadAllBytes();
     return ResultStatus::Success;
 }
 
 ResultStatus AppLoader_XCI::ReadTitle(std::string& title) {
     if (nacp_file == nullptr)
-        return ResultStatus::ErrorNoControl;
+        return ResultStatus::ErrorInvalidFormat;
     title = nacp_file->GetApplicationName();
     return ResultStatus::Success;
 }

src/core/settings.cpp

@@ -7,18 +7,22 @@
 #include "core/hle/service/hid/hid.h"
 #include "core/settings.h"
 #include "video_core/renderer_base.h"
+#include "video_core/video_core.h"
 
 namespace Settings {
 
 Values values = {};
 
 void Apply() {
+
     GDBStub::SetServerPort(values.gdbstub_port);
     GDBStub::ToggleServer(values.use_gdbstub);
 
+    VideoCore::g_toggle_framelimit_enabled = values.toggle_framelimit;
+
     auto& system_instance = Core::System::GetInstance();
     if (system_instance.IsPoweredOn()) {
-        system_instance.Renderer().RefreshBaseSettings();
+        system_instance.Renderer().UpdateCurrentFramebufferLayout();
     }
 
     Service::HID::ReloadInputDevices();

src/video_core/command_processor.h

@@ -30,7 +30,8 @@ union CommandHeader {
 
     BitField<29, 3, SubmissionMode> mode;
 };
-static_assert(std::is_standard_layout_v<CommandHeader>, "CommandHeader is not standard layout");
+static_assert(std::is_standard_layout<CommandHeader>::value == true,
+              "CommandHeader does not use standard layout");
 static_assert(sizeof(CommandHeader) == sizeof(u32), "CommandHeader has incorrect size!");
 
 } // namespace Tegra

src/video_core/engines/maxwell_3d.h

@@ -93,7 +93,6 @@ public:
 
         struct VertexAttribute {
             enum class Size : u32 {
-                Invalid = 0x0,
                 Size_32_32_32_32 = 0x01,
                 Size_32_32_32 = 0x02,
                 Size_16_16_16_16 = 0x03,
@@ -258,10 +257,6 @@ public:
             bool IsNormalized() const {
                 return (type == Type::SignedNorm) || (type == Type::UnsignedNorm);
             }
-
-            bool IsValid() const {
-                return size != Size::Invalid;
-            }
         };
 
         enum class PrimitiveTopology : u32 {
@@ -357,27 +352,6 @@ public:
                 OneMinusConstantColor = 0x62,
                 ConstantAlpha = 0x63,
                 OneMinusConstantAlpha = 0x64,
-
-                // These values are used by Nouveau and some games.
-                ZeroGL = 0x4000,
-                OneGL = 0x4001,
-                SourceColorGL = 0x4300,
-                OneMinusSourceColorGL = 0x4301,
-                SourceAlphaGL = 0x4302,
-                OneMinusSourceAlphaGL = 0x4303,
-                DestAlphaGL = 0x4304,
-                OneMinusDestAlphaGL = 0x4305,
-                DestColorGL = 0x4306,
-                OneMinusDestColorGL = 0x4307,
-                SourceAlphaSaturateGL = 0x4308,
-                ConstantColorGL = 0xc001,
-                OneMinusConstantColorGL = 0xc002,
-                ConstantAlphaGL = 0xc003,
-                OneMinusConstantAlphaGL = 0xc004,
-                Source1ColorGL = 0xc900,
-                OneMinusSource1ColorGL = 0xc901,
-                Source1AlphaGL = 0xc902,
-                OneMinusSource1AlphaGL = 0xc903,
             };
 
             u32 separate_alpha;

src/video_core/engines/shader_bytecode.h

@@ -74,11 +74,12 @@ union Attribute {
     enum class Index : u64 {
         Position = 7,
         Attribute_0 = 8,
-        Attribute_31 = 39,
         // 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
         // shader.
         TessCoordInstanceIDVertexID = 47,
+        // TODO(bunnei): Figure out what this is used for. Super Mario Odyssey uses this.
+        Unknown_63 = 63,
     };
 
     union {
@@ -200,14 +201,6 @@ enum class IMinMaxExchange : u64 {
     XHi = 3,
 };
 
-enum class XmadMode : u64 {
-    None = 0,
-    CLo = 1,
-    CHi = 2,
-    CSfu = 3,
-    CBcc = 4,
-};
-
 enum class FlowCondition : u64 {
     Always = 0xF,
     Fcsm_Tr = 0x1C, // TODO(bunnei): What is this used for?
@@ -464,18 +457,6 @@ union Instruction {
         }
     } bra;
 
-    union {
-        BitField<20, 16, u64> imm20_16;
-        BitField<36, 1, u64> product_shift_left;
-        BitField<37, 1, u64> merge_37;
-        BitField<48, 1, u64> sign_a;
-        BitField<49, 1, u64> sign_b;
-        BitField<50, 3, XmadMode> mode;
-        BitField<52, 1, u64> high_b;
-        BitField<53, 1, u64> high_a;
-        BitField<56, 1, u64> merge_56;
-    } xmad;
-
     union {
         BitField<20, 14, u64> offset;
         BitField<34, 5, u64> index;
@@ -496,7 +477,8 @@ union Instruction {
     u64 value;
 };
 static_assert(sizeof(Instruction) == 0x8, "Incorrect structure size");
-static_assert(std::is_standard_layout_v<Instruction>, "Instruction is not standard layout");
+static_assert(std::is_standard_layout<Instruction>::value,
+              "Structure does not have standard layout");
 
 class OpCode {
 public:
@@ -613,17 +595,9 @@ public:
         IntegerSetPredicate,
         PredicateSetPredicate,
         Conversion,
-        Xmad,
         Unknown,
     };
 
-    /// Returns whether an opcode has an execution predicate field or not (ie, whether it can be
-    /// conditionally executed).
-    static bool IsPredicatedInstruction(Id opcode) {
-        // TODO(Subv): Add the rest of unpredicated instructions.
-        return opcode != Id::SSY;
-    }
-
     class Matcher {
     public:
         Matcher(const char* const name, u16 mask, u16 expected, OpCode::Id id, OpCode::Type type)
@@ -803,10 +777,10 @@ private:
             INST("010010110101----", Id::ISET_C, Type::IntegerSet, "ISET_C"),
             INST("0011011-0101----", Id::ISET_IMM, Type::IntegerSet, "ISET_IMM"),
             INST("0101000010010---", Id::PSETP, Type::PredicateSetPredicate, "PSETP"),
-            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"),
-            INST("0101101100------", Id::XMAD_RR, Type::Xmad, "XMAD_RR"),
+            INST("0011011-00------", Id::XMAD_IMM, Type::Arithmetic, "XMAD_IMM"),
+            INST("0100111---------", Id::XMAD_CR, Type::Arithmetic, "XMAD_CR"),
+            INST("010100010-------", Id::XMAD_RC, Type::Arithmetic, "XMAD_RC"),
+            INST("0101101100------", Id::XMAD_RR, Type::Arithmetic, "XMAD_RR"),
         };
 #undef INST
         std::stable_sort(table.begin(), table.end(), [](const auto& a, const auto& b) {

src/video_core/gpu.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "common/assert.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/maxwell_compute.h"
@@ -12,15 +11,6 @@
 
 namespace Tegra {
 
-u32 FramebufferConfig::BytesPerPixel(PixelFormat format) {
-    switch (format) {
-    case PixelFormat::ABGR8:
-        return 4;
-    }
-
-    UNREACHABLE();
-}
-
 GPU::GPU(VideoCore::RasterizerInterface& rasterizer) {
     memory_manager = std::make_unique<MemoryManager>();
     maxwell_3d = std::make_unique<Engines::Maxwell3D>(rasterizer, *memory_manager);
@@ -44,58 +34,19 @@ u32 RenderTargetBytesPerPixel(RenderTargetFormat format) {
 
     switch (format) {
     case RenderTargetFormat::RGBA32_FLOAT:
-    case RenderTargetFormat::RGBA32_UINT:
         return 16;
-    case RenderTargetFormat::RGBA16_UINT:
     case RenderTargetFormat::RGBA16_FLOAT:
     case RenderTargetFormat::RG32_FLOAT:
-    case RenderTargetFormat::RG32_UINT:
         return 8;
     case RenderTargetFormat::RGBA8_UNORM:
-    case RenderTargetFormat::RGBA8_SNORM:
-    case RenderTargetFormat::RGBA8_SRGB:
     case RenderTargetFormat::RGB10_A2_UNORM:
     case RenderTargetFormat::BGRA8_UNORM:
-    case RenderTargetFormat::RG16_UNORM:
-    case RenderTargetFormat::RG16_SNORM:
-    case RenderTargetFormat::RG16_UINT:
-    case RenderTargetFormat::RG16_SINT:
-    case RenderTargetFormat::RG16_FLOAT:
     case RenderTargetFormat::R32_FLOAT:
     case RenderTargetFormat::R11G11B10_FLOAT:
-    case RenderTargetFormat::R32_UINT:
         return 4;
-    case RenderTargetFormat::R16_UNORM:
-    case RenderTargetFormat::R16_SNORM:
-    case RenderTargetFormat::R16_UINT:
-    case RenderTargetFormat::R16_SINT:
-    case RenderTargetFormat::R16_FLOAT:
-    case RenderTargetFormat::RG8_UNORM:
-    case RenderTargetFormat::RG8_SNORM:
-        return 2;
-    case RenderTargetFormat::R8_UNORM:
-    case RenderTargetFormat::R8_UINT:
-        return 1;
     default:
         UNIMPLEMENTED_MSG("Unimplemented render target format {}", static_cast<u32>(format));
     }
 }
 
-u32 DepthFormatBytesPerPixel(DepthFormat format) {
-    switch (format) {
-    case DepthFormat::Z32_S8_X24_FLOAT:
-        return 8;
-    case DepthFormat::Z32_FLOAT:
-    case DepthFormat::S8_Z24_UNORM:
-    case DepthFormat::Z24_X8_UNORM:
-    case DepthFormat::Z24_S8_UNORM:
-    case DepthFormat::Z24_C8_UNORM:
-        return 4;
-    case DepthFormat::Z16_UNORM:
-        return 2;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented Depth format {}", static_cast<u32>(format));
-    }
-}
-
 } // namespace Tegra

src/video_core/gpu.h

@@ -6,6 +6,7 @@
 
 #include <memory>
 #include <unordered_map>
+#include <vector>
 #include "common/common_types.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 #include "video_core/memory_manager.h"
@@ -20,33 +21,22 @@ enum class RenderTargetFormat : u32 {
     NONE = 0x0,
     RGBA32_FLOAT = 0xC0,
     RGBA32_UINT = 0xC2,
-    RGBA16_UINT = 0xC9,
     RGBA16_FLOAT = 0xCA,
     RG32_FLOAT = 0xCB,
-    RG32_UINT = 0xCD,
     BGRA8_UNORM = 0xCF,
     RGB10_A2_UNORM = 0xD1,
     RGBA8_UNORM = 0xD5,
     RGBA8_SRGB = 0xD6,
-    RGBA8_SNORM = 0xD7,
     RG16_UNORM = 0xDA,
     RG16_SNORM = 0xDB,
     RG16_SINT = 0xDC,
     RG16_UINT = 0xDD,
     RG16_FLOAT = 0xDE,
     R11G11B10_FLOAT = 0xE0,
-    R32_UINT = 0xE4,
     R32_FLOAT = 0xE5,
     B5G6R5_UNORM = 0xE8,
-    RG8_UNORM = 0xEA,
-    RG8_SNORM = 0xEB,
-    R16_UNORM = 0xEE,
-    R16_SNORM = 0xEF,
-    R16_SINT = 0xF0,
-    R16_UINT = 0xF1,
     R16_FLOAT = 0xF2,
     R8_UNORM = 0xF3,
-    R8_UINT = 0xF6,
 };
 
 enum class DepthFormat : u32 {
@@ -62,9 +52,6 @@ enum class DepthFormat : u32 {
 /// Returns the number of bytes per pixel of each rendertarget format.
 u32 RenderTargetBytesPerPixel(RenderTargetFormat format);
 
-/// Returns the number of bytes per pixel of each depth format.
-u32 DepthFormatBytesPerPixel(DepthFormat format);
-
 class DebugContext;
 
 /**
@@ -78,7 +65,14 @@ struct FramebufferConfig {
     /**
      * Returns the number of bytes per pixel.
      */
-    static u32 BytesPerPixel(PixelFormat format);
+    static u32 BytesPerPixel(PixelFormat format) {
+        switch (format) {
+        case PixelFormat::ABGR8:
+            return 4;
+        }
+
+        UNREACHABLE();
+    }
 
     VAddr address;
     u32 offset;

src/video_core/renderer_base.cpp

@@ -4,23 +4,18 @@
 
 #include <memory>
 #include "core/frontend/emu_window.h"
-#include "core/settings.h"
 #include "video_core/renderer_base.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 
 namespace VideoCore {
 
-RendererBase::RendererBase(Core::Frontend::EmuWindow& window) : render_window{window} {
-    RefreshBaseSettings();
-}
-
+RendererBase::RendererBase(EmuWindow& window) : render_window{window} {}
 RendererBase::~RendererBase() = default;
 
-void RendererBase::RefreshBaseSettings() {
-    RefreshRasterizerSetting();
-    UpdateCurrentFramebufferLayout();
+void RendererBase::UpdateCurrentFramebufferLayout() {
+    const Layout::FramebufferLayout& layout = render_window.GetFramebufferLayout();
 
-    renderer_settings.use_framelimiter = Settings::values.toggle_framelimit;
+    render_window.UpdateCurrentFramebufferLayout(layout.width, layout.height);
 }
 
 void RendererBase::RefreshRasterizerSetting() {
@@ -29,10 +24,4 @@ void RendererBase::RefreshRasterizerSetting() {
     }
 }
 
-void RendererBase::UpdateCurrentFramebufferLayout() {
-    const Layout::FramebufferLayout& layout = render_window.GetFramebufferLayout();
-
-    render_window.UpdateCurrentFramebufferLayout(layout.width, layout.height);
-}
-
 } // namespace VideoCore

src/video_core/renderer_base.h

@@ -4,26 +4,23 @@
 
 #pragma once
 
-#include <atomic>
 #include <memory>
 #include <boost/optional.hpp>
+#include "common/assert.h"
 #include "common/common_types.h"
 #include "video_core/gpu.h"
 #include "video_core/rasterizer_interface.h"
 
-namespace Core::Frontend {
 class EmuWindow;
-}
 
 namespace VideoCore {
 
-struct RendererSettings {
-    std::atomic_bool use_framelimiter{false};
-};
-
 class RendererBase : NonCopyable {
 public:
-    explicit RendererBase(Core::Frontend::EmuWindow& window);
+    /// Used to reference a framebuffer
+    enum kFramebuffer { kFramebuffer_VirtualXFB = 0, kFramebuffer_EFB, kFramebuffer_Texture };
+
+    explicit RendererBase(EmuWindow& window);
     virtual ~RendererBase();
 
     /// Swap buffers (render frame)
@@ -35,6 +32,9 @@ public:
     /// Shutdown the renderer
     virtual void ShutDown() = 0;
 
+    /// Updates the framebuffer layout of the contained render window handle.
+    void UpdateCurrentFramebufferLayout();
+
     // Getter/setter functions:
     // ------------------------
 
@@ -54,23 +54,13 @@ public:
         return *rasterizer;
     }
 
-    /// Refreshes the settings common to all renderers
-    void RefreshBaseSettings();
-
-protected:
-    /// Refreshes settings specific to the rasterizer.
     void RefreshRasterizerSetting();
 
-    Core::Frontend::EmuWindow& render_window; ///< Reference to the render window handle.
+protected:
+    EmuWindow& render_window; ///< Reference to the render window handle.
     std::unique_ptr<RasterizerInterface> rasterizer;
     f32 m_current_fps = 0.0f; ///< Current framerate, should be set by the renderer
     int m_current_frame = 0;  ///< Current frame, should be set by the renderer
-
-    RendererSettings renderer_settings;
-
-private:
-    /// Updates the framebuffer layout of the contained render window handle.
-    void UpdateCurrentFramebufferLayout();
 };
 
 } // namespace VideoCore

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -36,21 +36,30 @@ MICROPROFILE_DEFINE(OpenGL_Drawing, "OpenGL", "Drawing", MP_RGB(128, 128, 192));
 MICROPROFILE_DEFINE(OpenGL_Blits, "OpenGL", "Blits", MP_RGB(100, 100, 255));
 MICROPROFILE_DEFINE(OpenGL_CacheManagement, "OpenGL", "Cache Mgmt", MP_RGB(100, 255, 100));
 
-RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window)
-    : emu_window{window}, stream_buffer(GL_ARRAY_BUFFER, STREAM_BUFFER_SIZE) {
+RasterizerOpenGL::RasterizerOpenGL(EmuWindow& window) : emu_window{window} {
     // Create sampler objects
     for (size_t i = 0; i < texture_samplers.size(); ++i) {
         texture_samplers[i].Create();
         state.texture_units[i].sampler = texture_samplers[i].sampler.handle;
     }
 
+    // Create SSBOs
+    for (size_t stage = 0; stage < ssbos.size(); ++stage) {
+        for (size_t buffer = 0; buffer < ssbos[stage].size(); ++buffer) {
+            ssbos[stage][buffer].Create();
+            state.draw.const_buffers[stage][buffer].ssbo = ssbos[stage][buffer].handle;
+        }
+    }
+
     GLint ext_num;
     glGetIntegerv(GL_NUM_EXTENSIONS, &ext_num);
     for (GLint i = 0; i < ext_num; i++) {
         const std::string_view extension{
             reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i))};
 
-        if (extension == "GL_ARB_direct_state_access") {
+        if (extension == "GL_ARB_buffer_storage") {
+            has_ARB_buffer_storage = true;
+        } else if (extension == "GL_ARB_direct_state_access") {
             has_ARB_direct_state_access = true;
         } else if (extension == "GL_ARB_separate_shader_objects") {
             has_ARB_separate_shader_objects = true;
@@ -77,31 +86,47 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window)
 
     hw_vao.Create();
 
-    state.draw.vertex_buffer = stream_buffer.GetHandle();
+    stream_buffer = OGLStreamBuffer::MakeBuffer(has_ARB_buffer_storage, GL_ARRAY_BUFFER);
+    stream_buffer->Create(STREAM_BUFFER_SIZE, STREAM_BUFFER_SIZE / 2);
+    state.draw.vertex_buffer = stream_buffer->GetHandle();
 
     shader_program_manager = std::make_unique<GLShader::ProgramManager>();
     state.draw.shader_program = 0;
     state.draw.vertex_array = hw_vao.handle;
     state.Apply();
 
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, stream_buffer.GetHandle());
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, stream_buffer->GetHandle());
+
+    for (unsigned index = 0; index < uniform_buffers.size(); ++index) {
+        auto& buffer = uniform_buffers[index];
+        buffer.Create();
+        glBindBuffer(GL_UNIFORM_BUFFER, buffer.handle);
+        glBufferData(GL_UNIFORM_BUFFER, sizeof(GLShader::MaxwellUniformData), nullptr,
+                     GL_STREAM_COPY);
+        glBindBufferBase(GL_UNIFORM_BUFFER, index, buffer.handle);
+    }
 
     glEnable(GL_BLEND);
 
-    glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uniform_buffer_alignment);
-
     LOG_CRITICAL(Render_OpenGL, "Sync fixed function OpenGL state here!");
 }
 
-RasterizerOpenGL::~RasterizerOpenGL() {}
+RasterizerOpenGL::~RasterizerOpenGL() {
+    if (stream_buffer != nullptr) {
+        state.draw.vertex_buffer = stream_buffer->GetHandle();
+        state.Apply();
+        stream_buffer->Release();
+    }
+}
 
 std::pair<u8*, GLintptr> RasterizerOpenGL::SetupVertexArrays(u8* array_ptr,
                                                              GLintptr buffer_offset) {
     MICROPROFILE_SCOPE(OpenGL_VAO);
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+    const auto& memory_manager = Core::System::GetInstance().GPU().memory_manager;
 
     state.draw.vertex_array = hw_vao.handle;
-    state.draw.vertex_buffer = stream_buffer.GetHandle();
+    state.draw.vertex_buffer = stream_buffer->GetHandle();
     state.Apply();
 
     // Upload all guest vertex arrays sequentially to our buffer
@@ -116,15 +141,16 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupVertexArrays(u8* array_ptr,
         ASSERT(end > start);
         u64 size = end - start + 1;
 
-        GLintptr vertex_buffer_offset;
-        std::tie(array_ptr, buffer_offset, vertex_buffer_offset) =
-            UploadMemory(array_ptr, buffer_offset, start, size);
+        // Copy vertex array data
+        Memory::ReadBlock(*memory_manager->GpuToCpuAddress(start), array_ptr, size);
 
         // Bind the vertex array to the buffer at the current offset.
-        glBindVertexBuffer(index, stream_buffer.GetHandle(), vertex_buffer_offset,
-                           vertex_array.stride);
+        glBindVertexBuffer(index, stream_buffer->GetHandle(), buffer_offset, vertex_array.stride);
 
         ASSERT_MSG(vertex_array.divisor == 0, "Vertex buffer divisor unimplemented");
+
+        array_ptr += size;
+        buffer_offset += size;
     }
 
     // Use the vertex array as-is, assumes that the data is formatted correctly for OpenGL.
@@ -135,16 +161,11 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupVertexArrays(u8* array_ptr,
     // assume every shader uses them all.
     for (unsigned index = 0; index < 16; ++index) {
         auto& attrib = regs.vertex_attrib_format[index];
-
-        // Ignore invalid attributes.
-        if (!attrib.IsValid())
-            continue;
-
-        auto& buffer = regs.vertex_array[attrib.buffer];
         LOG_TRACE(HW_GPU, "vertex attrib {}, count={}, size={}, type={}, offset={}, normalize={}",
                   index, attrib.ComponentCount(), attrib.SizeString(), attrib.TypeString(),
                   attrib.offset.Value(), attrib.IsNormalized());
 
+        auto& buffer = regs.vertex_array[attrib.buffer];
         ASSERT(buffer.IsEnabled());
 
         glEnableVertexAttribArray(index);
@@ -175,12 +196,22 @@ static GLShader::ProgramCode GetShaderProgramCode(Maxwell::ShaderProgram program
     return program_code;
 }
 
-std::pair<u8*, GLintptr> RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
+void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
+    // Helper function for uploading uniform data
+    const auto copy_buffer = [&](GLuint handle, GLintptr offset, GLsizeiptr size) {
+        if (has_ARB_direct_state_access) {
+            glCopyNamedBufferSubData(stream_buffer->GetHandle(), handle, offset, 0, size);
+        } else {
+            glBindBuffer(GL_COPY_WRITE_BUFFER, handle);
+            glCopyBufferSubData(GL_ARRAY_BUFFER, GL_COPY_WRITE_BUFFER, offset, 0, size);
+        }
+    };
+
     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_constbuffer_bindpoint = Tegra::Engines::Maxwell3D::Regs::MaxShaderStage;
+    u32 current_constbuffer_bindpoint = uniform_buffers.size();
     u32 current_texture_bindpoint = 0;
 
     for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
@@ -192,21 +223,22 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr
             continue;
         }
 
-        std::tie(buffer_ptr, buffer_offset) =
-            AlignBuffer(buffer_ptr, buffer_offset, static_cast<size_t>(uniform_buffer_alignment));
-
         const size_t stage{index == 0 ? 0 : index - 1}; // Stage indices are 0 - 5
 
         GLShader::MaxwellUniformData ubo{};
         ubo.SetFromRegs(gpu.state.shader_stages[stage]);
         std::memcpy(buffer_ptr, &ubo, sizeof(ubo));
 
-        // Bind the buffer
-        glBindBufferRange(GL_UNIFORM_BUFFER, stage, stream_buffer.GetHandle(), buffer_offset,
-                          sizeof(ubo));
+        // Flush the buffer so that the GPU can see the data we just wrote.
+        glFlushMappedBufferRange(GL_ARRAY_BUFFER, buffer_offset, sizeof(ubo));
 
-        buffer_ptr += sizeof(ubo);
-        buffer_offset += sizeof(ubo);
+        // Upload uniform data as one UBO per stage
+        const GLintptr ubo_offset = buffer_offset;
+        copy_buffer(uniform_buffers[stage].handle, ubo_offset,
+                    sizeof(GLShader::MaxwellUniformData));
+
+        buffer_ptr += sizeof(GLShader::MaxwellUniformData);
+        buffer_offset += sizeof(GLShader::MaxwellUniformData);
 
         GLShader::ShaderSetup setup{GetShaderProgramCode(program)};
         GLShader::ShaderEntries shader_resources;
@@ -245,9 +277,9 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr
             static_cast<Maxwell::ShaderStage>(stage));
 
         // Configure the const buffers for this shader stage.
-        std::tie(buffer_ptr, buffer_offset, current_constbuffer_bindpoint) = SetupConstBuffers(
-            buffer_ptr, buffer_offset, static_cast<Maxwell::ShaderStage>(stage), gl_stage_program,
-            current_constbuffer_bindpoint, shader_resources.const_buffer_entries);
+        current_constbuffer_bindpoint =
+            SetupConstBuffers(static_cast<Maxwell::ShaderStage>(stage), gl_stage_program,
+                              current_constbuffer_bindpoint, shader_resources.const_buffer_entries);
 
         // Configure the textures for this shader stage.
         current_texture_bindpoint =
@@ -262,8 +294,6 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr
     }
 
     shader_program_manager->UseTrivialGeometryShader();
-
-    return {buffer_ptr, buffer_offset};
 }
 
 size_t RasterizerOpenGL::CalculateVertexArraysSize() const {
@@ -302,6 +332,8 @@ std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_c
     // TODO(bunnei): Implement this
     const bool has_stencil = false;
 
+    const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[0].GetRect()};
+
     const bool write_color_fb =
         state.color_mask.red_enabled == GL_TRUE || state.color_mask.green_enabled == GL_TRUE ||
         state.color_mask.blue_enabled == GL_TRUE || state.color_mask.alpha_enabled == GL_TRUE;
@@ -314,10 +346,9 @@ std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_c
     Surface depth_surface;
     MathUtil::Rectangle<u32> surfaces_rect;
     std::tie(color_surface, depth_surface, surfaces_rect) =
-        res_cache.GetFramebufferSurfaces(using_color_fb, using_depth_fb);
+        res_cache.GetFramebufferSurfaces(using_color_fb, using_depth_fb, viewport_rect);
 
-    const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[0].GetRect()};
-    const MathUtil::Rectangle<u32> draw_rect{
+    MathUtil::Rectangle<u32> draw_rect{
         static_cast<u32>(std::clamp<s32>(static_cast<s32>(surfaces_rect.left) + viewport_rect.left,
                                          surfaces_rect.left, surfaces_rect.right)), // Left
         static_cast<u32>(std::clamp<s32>(static_cast<s32>(surfaces_rect.bottom) + viewport_rect.top,
@@ -397,31 +428,6 @@ void RasterizerOpenGL::Clear() {
     }
 }
 
-std::pair<u8*, GLintptr> RasterizerOpenGL::AlignBuffer(u8* buffer_ptr, GLintptr buffer_offset,
-                                                       size_t alignment) {
-    // Align the offset, not the mapped pointer
-    GLintptr offset_aligned =
-        static_cast<GLintptr>(Common::AlignUp(static_cast<size_t>(buffer_offset), alignment));
-    return {buffer_ptr + (offset_aligned - buffer_offset), offset_aligned};
-}
-
-std::tuple<u8*, GLintptr, GLintptr> RasterizerOpenGL::UploadMemory(u8* buffer_ptr,
-                                                                   GLintptr buffer_offset,
-                                                                   Tegra::GPUVAddr gpu_addr,
-                                                                   size_t size, size_t alignment) {
-    std::tie(buffer_ptr, buffer_offset) = AlignBuffer(buffer_ptr, buffer_offset, alignment);
-    GLintptr uploaded_offset = buffer_offset;
-
-    const auto& memory_manager = Core::System::GetInstance().GPU().memory_manager;
-    const boost::optional<VAddr> cpu_addr{memory_manager->GpuToCpuAddress(gpu_addr)};
-    Memory::ReadBlock(*cpu_addr, buffer_ptr, size);
-
-    buffer_ptr += size;
-    buffer_offset += size;
-
-    return {buffer_ptr, buffer_offset, uploaded_offset};
-}
-
 void RasterizerOpenGL::DrawArrays() {
     if (accelerate_draw == AccelDraw::Disabled)
         return;
@@ -446,7 +452,7 @@ void RasterizerOpenGL::DrawArrays() {
     const u64 index_buffer_size{regs.index_array.count * regs.index_array.FormatSizeInBytes()};
     const unsigned vertex_num{is_indexed ? regs.index_array.count : regs.vertex_buffer.count};
 
-    state.draw.vertex_buffer = stream_buffer.GetHandle();
+    state.draw.vertex_buffer = stream_buffer->GetHandle();
     state.Apply();
 
     size_t buffer_size = CalculateVertexArraysSize();
@@ -456,31 +462,41 @@ void RasterizerOpenGL::DrawArrays() {
     }
 
     // Uniform space for the 5 shader stages
-    buffer_size =
-        Common::AlignUp<size_t>(buffer_size, 4) +
-        (sizeof(GLShader::MaxwellUniformData) + uniform_buffer_alignment) * Maxwell::MaxShaderStage;
-
-    // Add space for at least 18 constant buffers
-    buffer_size += Maxwell::MaxConstBuffers * (MaxConstbufferSize + uniform_buffer_alignment);
+    buffer_size = Common::AlignUp<size_t>(buffer_size, 4) +
+                  sizeof(GLShader::MaxwellUniformData) * Maxwell::MaxShaderStage;
 
     u8* buffer_ptr;
     GLintptr buffer_offset;
-    std::tie(buffer_ptr, buffer_offset, std::ignore) =
-        stream_buffer.Map(static_cast<GLsizeiptr>(buffer_size), 4);
-    u8* buffer_ptr_base = buffer_ptr;
+    std::tie(buffer_ptr, buffer_offset) =
+        stream_buffer->Map(static_cast<GLsizeiptr>(buffer_size), 4);
 
-    std::tie(buffer_ptr, buffer_offset) = SetupVertexArrays(buffer_ptr, buffer_offset);
+    u8* offseted_buffer;
+    std::tie(offseted_buffer, buffer_offset) = SetupVertexArrays(buffer_ptr, buffer_offset);
+
+    offseted_buffer =
+        reinterpret_cast<u8*>(Common::AlignUp(reinterpret_cast<size_t>(offseted_buffer), 4));
+    buffer_offset = Common::AlignUp<size_t>(buffer_offset, 4);
 
     // If indexed mode, copy the index buffer
     GLintptr index_buffer_offset = 0;
     if (is_indexed) {
-        std::tie(buffer_ptr, buffer_offset, index_buffer_offset) = UploadMemory(
-            buffer_ptr, buffer_offset, regs.index_array.StartAddress(), index_buffer_size);
+        const auto& memory_manager = Core::System::GetInstance().GPU().memory_manager;
+        const boost::optional<VAddr> index_data_addr{
+            memory_manager->GpuToCpuAddress(regs.index_array.StartAddress())};
+        Memory::ReadBlock(*index_data_addr, offseted_buffer, index_buffer_size);
+
+        index_buffer_offset = buffer_offset;
+        offseted_buffer += index_buffer_size;
+        buffer_offset += index_buffer_size;
     }
 
-    std::tie(buffer_ptr, buffer_offset) = SetupShaders(buffer_ptr, buffer_offset);
+    offseted_buffer =
+        reinterpret_cast<u8*>(Common::AlignUp(reinterpret_cast<size_t>(offseted_buffer), 4));
+    buffer_offset = Common::AlignUp<size_t>(buffer_offset, 4);
 
-    stream_buffer.Unmap(buffer_ptr - buffer_ptr_base);
+    SetupShaders(offseted_buffer, buffer_offset);
+
+    stream_buffer->Unmap();
 
     shader_program_manager->ApplyTo(state);
     state.Apply();
@@ -627,23 +643,36 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntr
     }
 }
 
-std::tuple<u8*, GLintptr, u32> RasterizerOpenGL::SetupConstBuffers(
-    u8* buffer_ptr, GLintptr buffer_offset, Maxwell::ShaderStage stage, GLuint program,
-    u32 current_bindpoint, const std::vector<GLShader::ConstBufferEntry>& entries) {
+u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, GLuint program,
+                                        u32 current_bindpoint,
+                                        const std::vector<GLShader::ConstBufferEntry>& entries) {
     const auto& gpu = Core::System::GetInstance().GPU();
     const auto& maxwell3d = gpu.Maxwell3D();
 
+    // Reset all buffer draw state for this stage.
+    for (auto& buffer : state.draw.const_buffers[static_cast<size_t>(stage)]) {
+        buffer.bindpoint = 0;
+        buffer.enabled = false;
+    }
+
     // Upload only the enabled buffers from the 16 constbuffers of each shader stage
     const auto& shader_stage = maxwell3d.state.shader_stages[static_cast<size_t>(stage)];
 
     for (u32 bindpoint = 0; bindpoint < entries.size(); ++bindpoint) {
         const auto& used_buffer = entries[bindpoint];
         const auto& buffer = shader_stage.const_buffers[used_buffer.GetIndex()];
+        auto& buffer_draw_state =
+            state.draw.const_buffers[static_cast<size_t>(stage)][used_buffer.GetIndex()];
 
         if (!buffer.enabled) {
             continue;
         }
 
+        buffer_draw_state.enabled = true;
+        buffer_draw_state.bindpoint = current_bindpoint + bindpoint;
+
+        boost::optional<VAddr> addr = gpu.memory_manager->GpuToCpuAddress(buffer.address);
+
         size_t size = 0;
 
         if (used_buffer.IsIndirect()) {
@@ -665,26 +694,25 @@ std::tuple<u8*, GLintptr, u32> RasterizerOpenGL::SetupConstBuffers(
         size = Common::AlignUp(size, sizeof(GLvec4));
         ASSERT_MSG(size <= MaxConstbufferSize, "Constbuffer too big");
 
-        GLintptr const_buffer_offset;
-        std::tie(buffer_ptr, buffer_offset, const_buffer_offset) =
-            UploadMemory(buffer_ptr, buffer_offset, buffer.address, size,
-                         static_cast<size_t>(uniform_buffer_alignment));
+        std::vector<u8> data(size);
+        Memory::ReadBlock(*addr, data.data(), data.size());
 
-        glBindBufferRange(GL_UNIFORM_BUFFER, current_bindpoint + bindpoint,
-                          stream_buffer.GetHandle(), const_buffer_offset, size);
+        glBindBuffer(GL_UNIFORM_BUFFER, buffer_draw_state.ssbo);
+        glBufferData(GL_UNIFORM_BUFFER, data.size(), data.data(), GL_DYNAMIC_DRAW);
+        glBindBuffer(GL_UNIFORM_BUFFER, 0);
 
         // Now configure the bindpoint of the buffer inside the shader
         const std::string buffer_name = used_buffer.GetName();
         const GLuint index =
             glGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, buffer_name.c_str());
         if (index != GL_INVALID_INDEX) {
-            glUniformBlockBinding(program, index, current_bindpoint + bindpoint);
+            glUniformBlockBinding(program, index, buffer_draw_state.bindpoint);
         }
     }
 
     state.Apply();
 
-    return {buffer_ptr, buffer_offset, current_bindpoint + static_cast<u32>(entries.size())};
+    return current_bindpoint + static_cast<u32>(entries.size());
 }
 
 u32 RasterizerOpenGL::SetupTextures(Maxwell::ShaderStage stage, GLuint program, u32 current_unit,
@@ -784,7 +812,9 @@ void RasterizerOpenGL::SyncClipCoef() {
 void RasterizerOpenGL::SyncCullMode() {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 
-    state.cull.enabled = regs.cull.enabled != 0;
+    // TODO(bunnei): Enable the below once more things work - until then, this may hide regressions
+    // state.cull.enabled = regs.cull.enabled != 0;
+    state.cull.enabled = false;
 
     if (state.cull.enabled) {
         state.cull.front_face = MaxwellToGL::FrontFace(regs.cull.front_face);

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -7,7 +7,6 @@
 #include <array>
 #include <cstddef>
 #include <memory>
-#include <tuple>
 #include <utility>
 #include <vector>
 #include <glad/glad.h>
@@ -22,15 +21,12 @@
 #include "video_core/renderer_opengl/gl_state.h"
 #include "video_core/renderer_opengl/gl_stream_buffer.h"
 
-struct ScreenInfo;
-
-namespace Core::Frontend {
 class EmuWindow;
-}
+struct ScreenInfo;
 
 class RasterizerOpenGL : public VideoCore::RasterizerInterface {
 public:
-    explicit RasterizerOpenGL(Core::Frontend::EmuWindow& renderer);
+    explicit RasterizerOpenGL(EmuWindow& renderer);
     ~RasterizerOpenGL() override;
 
     void DrawArrays() override;
@@ -101,10 +97,9 @@ private:
      * @param entries Vector describing the buffers that are actually used in the guest shader.
      * @returns The next available bindpoint for use in the next shader stage.
      */
-    std::tuple<u8*, GLintptr, u32> SetupConstBuffers(
-        u8* buffer_ptr, GLintptr buffer_offset, Tegra::Engines::Maxwell3D::Regs::ShaderStage stage,
-        GLuint program, u32 current_bindpoint,
-        const std::vector<GLShader::ConstBufferEntry>& entries);
+    u32 SetupConstBuffers(Tegra::Engines::Maxwell3D::Regs::ShaderStage stage, GLuint program,
+                          u32 current_bindpoint,
+                          const std::vector<GLShader::ConstBufferEntry>& entries);
 
     /*
      * Configures the current textures to use for the draw command.
@@ -141,6 +136,7 @@ private:
     /// Syncs the blend state to match the guest state
     void SyncBlendState();
 
+    bool has_ARB_buffer_storage = false;
     bool has_ARB_direct_state_access = false;
     bool has_ARB_separate_shader_objects = false;
     bool has_ARB_vertex_attrib_binding = false;
@@ -149,31 +145,29 @@ private:
 
     RasterizerCacheOpenGL res_cache;
 
-    Core::Frontend::EmuWindow& emu_window;
+    EmuWindow& emu_window;
 
     std::unique_ptr<GLShader::ProgramManager> shader_program_manager;
     OGLVertexArray sw_vao;
     OGLVertexArray hw_vao;
 
     std::array<SamplerInfo, GLShader::NumTextureSamplers> texture_samplers;
+    std::array<std::array<OGLBuffer, Tegra::Engines::Maxwell3D::Regs::MaxConstBuffers>,
+               Tegra::Engines::Maxwell3D::Regs::MaxShaderStage>
+        ssbos;
 
     static constexpr size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
-    OGLStreamBuffer stream_buffer;
+    std::unique_ptr<OGLStreamBuffer> stream_buffer;
     OGLBuffer uniform_buffer;
     OGLFramebuffer framebuffer;
-    GLint uniform_buffer_alignment;
 
     size_t CalculateVertexArraysSize() const;
 
     std::pair<u8*, GLintptr> SetupVertexArrays(u8* array_ptr, GLintptr buffer_offset);
 
-    std::pair<u8*, GLintptr> SetupShaders(u8* buffer_ptr, GLintptr buffer_offset);
+    std::array<OGLBuffer, Tegra::Engines::Maxwell3D::Regs::MaxShaderStage> uniform_buffers;
 
-    std::pair<u8*, GLintptr> AlignBuffer(u8* buffer_ptr, GLintptr buffer_offset, size_t alignment);
-
-    std::tuple<u8*, GLintptr, GLintptr> UploadMemory(u8* buffer_ptr, GLintptr buffer_offset,
-                                                     Tegra::GPUVAddr gpu_addr, size_t size,
-                                                     size_t alignment = 4);
+    void SetupShaders(u8* buffer_ptr, GLintptr buffer_offset);
 
     enum class AccelDraw { Disabled, Arrays, Indexed };
     AccelDraw accelerate_draw = AccelDraw::Disabled;

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -92,16 +92,13 @@ struct FormatTuple {
 }
 
 static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_format_tuples = {{
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // ABGR8U
-    {GL_RGBA8, GL_RGBA, GL_BYTE, ComponentType::SNorm, false},                     // ABGR8S
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // ABGR8
     {GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, ComponentType::UNorm, false},    // B5G6R5
     {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, ComponentType::UNorm,
      false}, // A2B10G10R10
     {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, ComponentType::UNorm, false}, // A1B5G5R5
     {GL_R8, GL_RED, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},                    // R8
-    {GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, ComponentType::UInt, false},           // R8UI
     {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT, ComponentType::Float, false},                 // RGBA16F
-    {GL_RGBA16UI, GL_RGBA, GL_UNSIGNED_SHORT, ComponentType::UInt, false},             // RGBA16UI
     {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, ComponentType::Float,
      false},                                                                     // R11FG11FB10F
     {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false}, // RGBA32UI
@@ -125,9 +122,6 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_R32F, GL_RED, GL_FLOAT, ComponentType::Float, false},                  // R32F
     {GL_R16F, GL_RED, GL_HALF_FLOAT, ComponentType::Float, false},             // R16F
     {GL_R16, GL_RED, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},          // R16UNORM
-    {GL_R16_SNORM, GL_RED, GL_SHORT, ComponentType::SNorm, false},             // R16S
-    {GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT, ComponentType::UInt, false}, // R16UI
-    {GL_R16I, GL_RED_INTEGER, GL_SHORT, ComponentType::SInt, false},           // R16I
     {GL_RG16, GL_RG, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},          // RG16
     {GL_RG16F, GL_RG, GL_HALF_FLOAT, ComponentType::Float, false},             // RG16F
     {GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT, ComponentType::UInt, false}, // RG16UI
@@ -135,10 +129,6 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_RG16_SNORM, GL_RG, GL_SHORT, ComponentType::SNorm, false},             // RG16S
     {GL_RGB32F, GL_RGB, GL_FLOAT, ComponentType::Float, false},                // RGB32F
     {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // SRGBA8
-    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},                       // RG8U
-    {GL_RG8, GL_RG, GL_BYTE, ComponentType::SNorm, false},                                // RG8S
-    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},              // RG32UI
-    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},              // R32UI
 
     // DepthStencil formats
     {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
@@ -193,21 +183,6 @@ MathUtil::Rectangle<u32> SurfaceParams::GetRect() const {
     return {0, actual_height, width, 0};
 }
 
-/// Returns true if the specified PixelFormat is a BCn format, e.g. DXT or DXN
-static bool IsFormatBCn(PixelFormat format) {
-    switch (format) {
-    case PixelFormat::DXT1:
-    case PixelFormat::DXT23:
-    case PixelFormat::DXT45:
-    case PixelFormat::DXN1:
-    case PixelFormat::DXN2SNORM:
-    case PixelFormat::DXN2UNORM:
-    case PixelFormat::BC7U:
-        return true;
-    }
-    return false;
-}
-
 template <bool morton_to_gl, PixelFormat format>
 void MortonCopy(u32 stride, u32 block_height, u32 height, std::vector<u8>& gl_buffer,
                 Tegra::GPUVAddr addr) {
@@ -216,12 +191,16 @@ void MortonCopy(u32 stride, u32 block_height, u32 height, std::vector<u8>& gl_bu
     const auto& gpu = Core::System::GetInstance().GPU();
 
     if (morton_to_gl) {
-        // With the BCn formats (DXT and DXN), each 4x4 tile is swizzled instead of just individual
-        // pixel values.
-        const u32 tile_size{IsFormatBCn(format) ? 4U : 1U};
-        const std::vector<u8> data =
-            Tegra::Texture::UnswizzleTexture(*gpu.memory_manager->GpuToCpuAddress(addr), tile_size,
-                                             bytes_per_pixel, stride, height, block_height);
+        std::vector<u8> data;
+        if (SurfaceParams::GetFormatType(format) == SurfaceType::ColorTexture) {
+            data = Tegra::Texture::UnswizzleTexture(
+                *gpu.memory_manager->GpuToCpuAddress(addr),
+                SurfaceParams::TextureFormatFromPixelFormat(format), stride, height, block_height);
+        } else {
+            data = Tegra::Texture::UnswizzleDepthTexture(
+                *gpu.memory_manager->GpuToCpuAddress(addr),
+                SurfaceParams::DepthFormatFromPixelFormat(format), stride, height, block_height);
+        }
         const size_t size_to_copy{std::min(gl_buffer.size(), data.size())};
         gl_buffer.assign(data.begin(), data.begin() + size_to_copy);
     } else {
@@ -238,68 +217,35 @@ void MortonCopy(u32 stride, u32 block_height, u32 height, std::vector<u8>& gl_bu
 static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPUVAddr),
                             SurfaceParams::MaxPixelFormat>
     morton_to_gl_fns = {
-        // clang-format off
-        MortonCopy<true, PixelFormat::ABGR8U>,
-        MortonCopy<true, PixelFormat::ABGR8S>,
-        MortonCopy<true, PixelFormat::B5G6R5>,
-        MortonCopy<true, PixelFormat::A2B10G10R10>,
-        MortonCopy<true, PixelFormat::A1B5G5R5>,
-        MortonCopy<true, PixelFormat::R8>,
-        MortonCopy<true, PixelFormat::R8UI>,
-        MortonCopy<true, PixelFormat::RGBA16F>,
-        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::ASTC_2D_4X4>,
-        MortonCopy<true, PixelFormat::G8R8>,
-        MortonCopy<true, PixelFormat::BGRA8>,
-        MortonCopy<true, PixelFormat::RGBA32F>,
-        MortonCopy<true, PixelFormat::RG32F>,
-        MortonCopy<true, PixelFormat::R32F>,
-        MortonCopy<true, PixelFormat::R16F>,
-        MortonCopy<true, PixelFormat::R16UNORM>,
-        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::SRGBA8>,
-        MortonCopy<true, PixelFormat::RG8U>,
-        MortonCopy<true, PixelFormat::RG8S>,
-        MortonCopy<true, PixelFormat::RG32UI>,
-        MortonCopy<true, PixelFormat::R32UI>,
-        MortonCopy<true, PixelFormat::Z24S8>,
-        MortonCopy<true, PixelFormat::S8Z24>,
-        MortonCopy<true, PixelFormat::Z32F>,
-        MortonCopy<true, PixelFormat::Z16>,
+        MortonCopy<true, PixelFormat::ABGR8>,        MortonCopy<true, PixelFormat::B5G6R5>,
+        MortonCopy<true, PixelFormat::A2B10G10R10>,  MortonCopy<true, PixelFormat::A1B5G5R5>,
+        MortonCopy<true, PixelFormat::R8>,           MortonCopy<true, PixelFormat::RGBA16F>,
+        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::ASTC_2D_4X4>,
+        MortonCopy<true, PixelFormat::G8R8>,         MortonCopy<true, PixelFormat::BGRA8>,
+        MortonCopy<true, PixelFormat::RGBA32F>,      MortonCopy<true, PixelFormat::RG32F>,
+        MortonCopy<true, PixelFormat::R32F>,         MortonCopy<true, PixelFormat::R16F>,
+        MortonCopy<true, PixelFormat::R16UNORM>,     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::SRGBA8>,
+        MortonCopy<true, PixelFormat::Z24S8>,        MortonCopy<true, PixelFormat::S8Z24>,
+        MortonCopy<true, PixelFormat::Z32F>,         MortonCopy<true, PixelFormat::Z16>,
         MortonCopy<true, PixelFormat::Z32FS8>,
-        // clang-format on
 };
 
 static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPUVAddr),
                             SurfaceParams::MaxPixelFormat>
     gl_to_morton_fns = {
-        // clang-format off
-        MortonCopy<false, PixelFormat::ABGR8U>,
-        MortonCopy<false, PixelFormat::ABGR8S>,
+        MortonCopy<false, PixelFormat::ABGR8>,
         MortonCopy<false, PixelFormat::B5G6R5>,
         MortonCopy<false, PixelFormat::A2B10G10R10>,
         MortonCopy<false, PixelFormat::A1B5G5R5>,
         MortonCopy<false, PixelFormat::R8>,
-        MortonCopy<false, PixelFormat::R8UI>,
         MortonCopy<false, PixelFormat::RGBA16F>,
-        MortonCopy<false, PixelFormat::RGBA16UI>,
         MortonCopy<false, PixelFormat::R11FG11FB10F>,
         MortonCopy<false, PixelFormat::RGBA32UI>,
         // TODO(Subv): Swizzling DXT1/DXT23/DXT45/DXN1/DXN2/BC7U/ASTC_2D_4X4 formats is not
@@ -319,9 +265,6 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         MortonCopy<false, PixelFormat::R32F>,
         MortonCopy<false, PixelFormat::R16F>,
         MortonCopy<false, PixelFormat::R16UNORM>,
-        MortonCopy<false, PixelFormat::R16S>,
-        MortonCopy<false, PixelFormat::R16UI>,
-        MortonCopy<false, PixelFormat::R16I>,
         MortonCopy<false, PixelFormat::RG16>,
         MortonCopy<false, PixelFormat::RG16F>,
         MortonCopy<false, PixelFormat::RG16UI>,
@@ -329,16 +272,11 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         MortonCopy<false, PixelFormat::RG16S>,
         MortonCopy<false, PixelFormat::RGB32F>,
         MortonCopy<false, PixelFormat::SRGBA8>,
-        MortonCopy<false, PixelFormat::RG8U>,
-        MortonCopy<false, PixelFormat::RG8S>,
-        MortonCopy<false, PixelFormat::RG32UI>,
-        MortonCopy<false, PixelFormat::R32UI>,
         MortonCopy<false, PixelFormat::Z24S8>,
         MortonCopy<false, PixelFormat::S8Z24>,
         MortonCopy<false, PixelFormat::Z32F>,
         MortonCopy<false, PixelFormat::Z16>,
         MortonCopy<false, PixelFormat::Z32FS8>,
-        // clang-format on
 };
 
 // Allocate an uninitialized texture of appropriate size and format for the surface
@@ -673,8 +611,8 @@ Surface RasterizerCacheOpenGL::GetTextureSurface(const Tegra::Texture::FullTextu
     return GetSurface(SurfaceParams::CreateForTexture(config));
 }
 
-SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool using_color_fb,
-                                                                       bool using_depth_fb) {
+SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(
+    bool using_color_fb, bool using_depth_fb, const MathUtil::Rectangle<s32>& viewport) {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 
     // TODO(bunnei): This is hard corded to use just the first render buffer

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -23,55 +23,45 @@ using PageMap = boost::icl::interval_map<u64, int>;
 
 struct SurfaceParams {
     enum class PixelFormat {
-        ABGR8U = 0,
-        ABGR8S = 1,
-        B5G6R5 = 2,
-        A2B10G10R10 = 3,
-        A1B5G5R5 = 4,
-        R8 = 5,
-        R8UI = 6,
-        RGBA16F = 7,
-        RGBA16UI = 8,
-        R11FG11FB10F = 9,
-        RGBA32UI = 10,
-        DXT1 = 11,
-        DXT23 = 12,
-        DXT45 = 13,
-        DXN1 = 14, // This is also known as BC4
-        DXN2UNORM = 15,
-        DXN2SNORM = 16,
-        BC7U = 17,
-        ASTC_2D_4X4 = 18,
-        G8R8 = 19,
-        BGRA8 = 20,
-        RGBA32F = 21,
-        RG32F = 22,
-        R32F = 23,
-        R16F = 24,
-        R16UNORM = 25,
-        R16S = 26,
-        R16UI = 27,
-        R16I = 28,
-        RG16 = 29,
-        RG16F = 30,
-        RG16UI = 31,
-        RG16I = 32,
-        RG16S = 33,
-        RGB32F = 34,
-        SRGBA8 = 35,
-        RG8U = 36,
-        RG8S = 37,
-        RG32UI = 38,
-        R32UI = 39,
+        ABGR8 = 0,
+        B5G6R5 = 1,
+        A2B10G10R10 = 2,
+        A1B5G5R5 = 3,
+        R8 = 4,
+        RGBA16F = 5,
+        R11FG11FB10F = 6,
+        RGBA32UI = 7,
+        DXT1 = 8,
+        DXT23 = 9,
+        DXT45 = 10,
+        DXN1 = 11, // This is also known as BC4
+        DXN2UNORM = 12,
+        DXN2SNORM = 13,
+        BC7U = 14,
+        ASTC_2D_4X4 = 15,
+        G8R8 = 16,
+        BGRA8 = 17,
+        RGBA32F = 18,
+        RG32F = 19,
+        R32F = 20,
+        R16F = 21,
+        R16UNORM = 22,
+        RG16 = 23,
+        RG16F = 24,
+        RG16UI = 25,
+        RG16I = 26,
+        RG16S = 27,
+        RGB32F = 28,
+        SRGBA8 = 29,
 
         MaxColorFormat,
 
         // DepthStencil formats
-        Z24S8 = 40,
-        S8Z24 = 41,
-        Z32F = 42,
-        Z16 = 43,
-        Z32FS8 = 44,
+        Z24S8 = 30,
+        S8Z24 = 31,
+        Z32F = 32,
+        Z16 = 33,
+        Z32FS8 = 34,
 
         MaxDepthStencilFormat,
 
@@ -109,15 +99,12 @@ struct SurfaceParams {
             return 0;
 
         constexpr std::array<u32, MaxPixelFormat> compression_factor_table = {{
-            1, // ABGR8U
-            1, // ABGR8S
+            1, // ABGR8
             1, // B5G6R5
             1, // A2B10G10R10
             1, // A1B5G5R5
             1, // R8
-            1, // R8UI
             1, // RGBA16F
-            1, // RGBA16UI
             1, // R11FG11FB10F
             1, // RGBA32UI
             4, // DXT1
@@ -135,9 +122,6 @@ struct SurfaceParams {
             1, // R32F
             1, // R16F
             1, // R16UNORM
-            1, // R16S
-            1, // R16UI
-            1, // R16I
             1, // RG16
             1, // RG16F
             1, // RG16UI
@@ -145,10 +129,6 @@ struct SurfaceParams {
             1, // RG16S
             1, // RGB32F
             1, // SRGBA8
-            1, // RG8U
-            1, // RG8S
-            1, // RG32UI
-            1, // R32UI
             1, // Z24S8
             1, // S8Z24
             1, // Z32F
@@ -165,15 +145,12 @@ struct SurfaceParams {
             return 0;
 
         constexpr std::array<u32, MaxPixelFormat> bpp_table = {{
-            32,  // ABGR8U
-            32,  // ABGR8S
+            32,  // ABGR8
             16,  // B5G6R5
             32,  // A2B10G10R10
             16,  // A1B5G5R5
             8,   // R8
-            8,   // R8UI
             64,  // RGBA16F
-            64,  // RGBA16UI
             32,  // R11FG11FB10F
             128, // RGBA32UI
             64,  // DXT1
@@ -191,9 +168,6 @@ struct SurfaceParams {
             32,  // R32F
             16,  // R16F
             16,  // R16UNORM
-            16,  // R16S
-            16,  // R16UI
-            16,  // R16I
             32,  // RG16
             32,  // RG16F
             32,  // RG16UI
@@ -201,10 +175,6 @@ struct SurfaceParams {
             32,  // RG16S
             96,  // RGB32F
             32,  // SRGBA8
-            16,  // RG8U
-            16,  // RG8S
-            64,  // RG32UI
-            32,  // R32UI
             32,  // Z24S8
             32,  // S8Z24
             32,  // Z32F
@@ -244,17 +214,13 @@ struct SurfaceParams {
         // gamma.
         case Tegra::RenderTargetFormat::RGBA8_SRGB:
         case Tegra::RenderTargetFormat::RGBA8_UNORM:
-            return PixelFormat::ABGR8U;
-        case Tegra::RenderTargetFormat::RGBA8_SNORM:
-            return PixelFormat::ABGR8S;
+            return PixelFormat::ABGR8;
         case Tegra::RenderTargetFormat::BGRA8_UNORM:
             return PixelFormat::BGRA8;
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
             return PixelFormat::A2B10G10R10;
         case Tegra::RenderTargetFormat::RGBA16_FLOAT:
             return PixelFormat::RGBA16F;
-        case Tegra::RenderTargetFormat::RGBA16_UINT:
-            return PixelFormat::RGBA16UI;
         case Tegra::RenderTargetFormat::RGBA32_FLOAT:
             return PixelFormat::RGBA32F;
         case Tegra::RenderTargetFormat::RG32_FLOAT:
@@ -267,8 +233,6 @@ struct SurfaceParams {
             return PixelFormat::RGBA32UI;
         case Tegra::RenderTargetFormat::R8_UNORM:
             return PixelFormat::R8;
-        case Tegra::RenderTargetFormat::R8_UINT:
-            return PixelFormat::R8UI;
         case Tegra::RenderTargetFormat::RG16_FLOAT:
             return PixelFormat::RG16F;
         case Tegra::RenderTargetFormat::RG16_UINT:
@@ -279,26 +243,10 @@ struct SurfaceParams {
             return PixelFormat::RG16;
         case Tegra::RenderTargetFormat::RG16_SNORM:
             return PixelFormat::RG16S;
-        case Tegra::RenderTargetFormat::RG8_UNORM:
-            return PixelFormat::RG8U;
-        case Tegra::RenderTargetFormat::RG8_SNORM:
-            return PixelFormat::RG8S;
         case Tegra::RenderTargetFormat::R16_FLOAT:
             return PixelFormat::R16F;
-        case Tegra::RenderTargetFormat::R16_UNORM:
-            return PixelFormat::R16UNORM;
-        case Tegra::RenderTargetFormat::R16_SNORM:
-            return PixelFormat::R16S;
-        case Tegra::RenderTargetFormat::R16_UINT:
-            return PixelFormat::R16UI;
-        case Tegra::RenderTargetFormat::R16_SINT:
-            return PixelFormat::R16I;
         case Tegra::RenderTargetFormat::R32_FLOAT:
             return PixelFormat::R32F;
-        case Tegra::RenderTargetFormat::R32_UINT:
-            return PixelFormat::R32UI;
-        case Tegra::RenderTargetFormat::RG32_UINT:
-            return PixelFormat::RG32UI;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
@@ -310,15 +258,7 @@ struct SurfaceParams {
         // TODO(Subv): Properly implement this
         switch (format) {
         case Tegra::Texture::TextureFormat::A8R8G8B8:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::UNORM:
-                return PixelFormat::ABGR8U;
-            case Tegra::Texture::ComponentType::SNORM:
-                return PixelFormat::ABGR8S;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::ABGR8;
         case Tegra::Texture::TextureFormat::B5G6R5:
             return PixelFormat::B5G6R5;
         case Tegra::Texture::TextureFormat::A2B10G10R10:
@@ -326,15 +266,7 @@ struct SurfaceParams {
         case Tegra::Texture::TextureFormat::A1B5G5R5:
             return PixelFormat::A1B5G5R5;
         case Tegra::Texture::TextureFormat::R8:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::UNORM:
-                return PixelFormat::R8;
-            case Tegra::Texture::ComponentType::UINT:
-                return PixelFormat::R8UI;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::R8;
         case Tegra::Texture::TextureFormat::G8R8:
             return PixelFormat::G8R8;
         case Tegra::Texture::TextureFormat::R16_G16_B16_A16:
@@ -352,15 +284,7 @@ struct SurfaceParams {
                          static_cast<u32>(component_type));
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::R32_G32:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::FLOAT:
-                return PixelFormat::RG32F;
-            case Tegra::Texture::ComponentType::UINT:
-                return PixelFormat::RG32UI;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::RG32F;
         case Tegra::Texture::TextureFormat::R32_G32_B32:
             return PixelFormat::RGB32F;
         case Tegra::Texture::TextureFormat::R16:
@@ -369,26 +293,12 @@ struct SurfaceParams {
                 return PixelFormat::R16F;
             case Tegra::Texture::ComponentType::UNORM:
                 return PixelFormat::R16UNORM;
-            case Tegra::Texture::ComponentType::SNORM:
-                return PixelFormat::R16S;
-            case Tegra::Texture::ComponentType::UINT:
-                return PixelFormat::R16UI;
-            case Tegra::Texture::ComponentType::SINT:
-                return PixelFormat::R16I;
             }
             LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
                          static_cast<u32>(component_type));
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::R32:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::FLOAT:
-                return PixelFormat::R32F;
-            case Tegra::Texture::ComponentType::UINT:
-                return PixelFormat::R32UI;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::R32F;
         case Tegra::Texture::TextureFormat::ZF32:
             return PixelFormat::Z32F;
         case Tegra::Texture::TextureFormat::Z24S8:
@@ -438,6 +348,92 @@ struct SurfaceParams {
         }
     }
 
+    static Tegra::Texture::TextureFormat TextureFormatFromPixelFormat(PixelFormat format) {
+        // TODO(Subv): Properly implement this
+        switch (format) {
+        case PixelFormat::ABGR8:
+        case PixelFormat::SRGBA8:
+            return Tegra::Texture::TextureFormat::A8R8G8B8;
+        case PixelFormat::B5G6R5:
+            return Tegra::Texture::TextureFormat::B5G6R5;
+        case PixelFormat::A2B10G10R10:
+            return Tegra::Texture::TextureFormat::A2B10G10R10;
+        case PixelFormat::A1B5G5R5:
+            return Tegra::Texture::TextureFormat::A1B5G5R5;
+        case PixelFormat::R8:
+            return Tegra::Texture::TextureFormat::R8;
+        case PixelFormat::G8R8:
+            return Tegra::Texture::TextureFormat::G8R8;
+        case PixelFormat::RGBA16F:
+            return Tegra::Texture::TextureFormat::R16_G16_B16_A16;
+        case PixelFormat::R11FG11FB10F:
+            return Tegra::Texture::TextureFormat::BF10GF11RF11;
+        case PixelFormat::RGBA32UI:
+            return Tegra::Texture::TextureFormat::R32_G32_B32_A32;
+        case PixelFormat::DXT1:
+            return Tegra::Texture::TextureFormat::DXT1;
+        case PixelFormat::DXT23:
+            return Tegra::Texture::TextureFormat::DXT23;
+        case PixelFormat::DXT45:
+            return Tegra::Texture::TextureFormat::DXT45;
+        case PixelFormat::DXN1:
+            return Tegra::Texture::TextureFormat::DXN1;
+        case PixelFormat::DXN2UNORM:
+        case PixelFormat::DXN2SNORM:
+            return Tegra::Texture::TextureFormat::DXN2;
+        case PixelFormat::BC7U:
+            return Tegra::Texture::TextureFormat::BC7U;
+        case PixelFormat::ASTC_2D_4X4:
+            return Tegra::Texture::TextureFormat::ASTC_2D_4X4;
+        case PixelFormat::BGRA8:
+            // TODO(bunnei): This is fine for unswizzling (since we just need the right component
+            // sizes), but could be a bug if we used this function in different ways.
+            return Tegra::Texture::TextureFormat::A8R8G8B8;
+        case PixelFormat::RGBA32F:
+            return Tegra::Texture::TextureFormat::R32_G32_B32_A32;
+        case PixelFormat::RGB32F:
+            return Tegra::Texture::TextureFormat::R32_G32_B32;
+        case PixelFormat::RG32F:
+            return Tegra::Texture::TextureFormat::R32_G32;
+        case PixelFormat::R32F:
+            return Tegra::Texture::TextureFormat::R32;
+        case PixelFormat::R16F:
+        case PixelFormat::R16UNORM:
+            return Tegra::Texture::TextureFormat::R16;
+        case PixelFormat::Z32F:
+            return Tegra::Texture::TextureFormat::ZF32;
+        case PixelFormat::Z24S8:
+            return Tegra::Texture::TextureFormat::Z24S8;
+        case PixelFormat::RG16F:
+        case PixelFormat::RG16:
+        case PixelFormat::RG16UI:
+        case PixelFormat::RG16I:
+        case PixelFormat::RG16S:
+            return Tegra::Texture::TextureFormat::R16_G16;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            UNREACHABLE();
+        }
+    }
+
+    static Tegra::DepthFormat DepthFormatFromPixelFormat(PixelFormat format) {
+        switch (format) {
+        case PixelFormat::S8Z24:
+            return Tegra::DepthFormat::S8_Z24_UNORM;
+        case PixelFormat::Z24S8:
+            return Tegra::DepthFormat::Z24_S8_UNORM;
+        case PixelFormat::Z32F:
+            return Tegra::DepthFormat::Z32_FLOAT;
+        case PixelFormat::Z16:
+            return Tegra::DepthFormat::Z16_UNORM;
+        case PixelFormat::Z32FS8:
+            return Tegra::DepthFormat::Z32_S8_X24_FLOAT;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            UNREACHABLE();
+        }
+    }
+
     static ComponentType ComponentTypeFromTexture(Tegra::Texture::ComponentType type) {
         // TODO(Subv): Implement more component types
         switch (type) {
@@ -466,14 +462,9 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
         case Tegra::RenderTargetFormat::R8_UNORM:
         case Tegra::RenderTargetFormat::RG16_UNORM:
-        case Tegra::RenderTargetFormat::R16_UNORM:
         case Tegra::RenderTargetFormat::B5G6R5_UNORM:
-        case Tegra::RenderTargetFormat::RG8_UNORM:
             return ComponentType::UNorm;
-        case Tegra::RenderTargetFormat::RGBA8_SNORM:
         case Tegra::RenderTargetFormat::RG16_SNORM:
-        case Tegra::RenderTargetFormat::R16_SNORM:
-        case Tegra::RenderTargetFormat::RG8_SNORM:
             return ComponentType::SNorm;
         case Tegra::RenderTargetFormat::RGBA16_FLOAT:
         case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
@@ -484,15 +475,9 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::R32_FLOAT:
             return ComponentType::Float;
         case Tegra::RenderTargetFormat::RGBA32_UINT:
-        case Tegra::RenderTargetFormat::RGBA16_UINT:
         case Tegra::RenderTargetFormat::RG16_UINT:
-        case Tegra::RenderTargetFormat::R8_UINT:
-        case Tegra::RenderTargetFormat::R16_UINT:
-        case Tegra::RenderTargetFormat::RG32_UINT:
-        case Tegra::RenderTargetFormat::R32_UINT:
             return ComponentType::UInt;
         case Tegra::RenderTargetFormat::RG16_SINT:
-        case Tegra::RenderTargetFormat::R16_SINT:
             return ComponentType::SInt;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
@@ -503,7 +488,7 @@ struct SurfaceParams {
     static PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format) {
         switch (format) {
         case Tegra::FramebufferConfig::PixelFormat::ABGR8:
-            return PixelFormat::ABGR8U;
+            return PixelFormat::ABGR8;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
@@ -649,7 +634,8 @@ public:
     Surface GetTextureSurface(const Tegra::Texture::FullTextureInfo& config);
 
     /// Get the color and depth surfaces based on the framebuffer configuration
-    SurfaceSurfaceRect_Tuple GetFramebufferSurfaces(bool using_color_fb, bool using_depth_fb);
+    SurfaceSurfaceRect_Tuple GetFramebufferSurfaces(bool using_color_fb, bool using_depth_fb,
+                                                    const MathUtil::Rectangle<s32>& viewport);
 
     /// Flushes the surface to Switch memory
     void FlushSurface(const Surface& surface);

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -141,15 +141,6 @@ private:
                     ExitMethod jmp = Scan(target, end, labels);
                     return exit_method = ParallelExit(no_jmp, jmp);
                 }
-                case OpCode::Id::SSY: {
-                    // The SSY instruction uses a similar encoding as the BRA instruction.
-                    ASSERT_MSG(instr.bra.constant_buffer == 0,
-                               "Constant buffer SSY is not supported");
-                    u32 target = offset + instr.bra.GetBranchTarget();
-                    labels.insert(target);
-                    // Continue scanning for an exit method.
-                    break;
-                }
                 }
             }
         }
@@ -356,14 +347,9 @@ public:
      * @param reg The register to use as the source value.
      */
     void SetOutputAttributeToRegister(Attribute::Index attribute, u64 elem, const Register& reg) {
-        std::string dest = GetOutputAttribute(attribute);
+        std::string dest = GetOutputAttribute(attribute) + GetSwizzle(elem);
         std::string src = GetRegisterAsFloat(reg);
-
-        if (!dest.empty()) {
-            // Can happen with unknown/unimplemented output attributes, in which case we ignore the
-            // instruction for now.
-            shader.AddLine(dest + GetSwizzle(elem) + " = " + src + ';');
-        }
+        shader.AddLine(dest + " = " + src + ';');
     }
 
     /// Generates code representing a uniform (C buffer) register, interpreted as the input type.
@@ -376,8 +362,6 @@ public:
             return value;
         } else if (type == GLSLRegister::Type::Integer) {
             return "floatBitsToInt(" + value + ')';
-        } else if (type == GLSLRegister::Type::UnsignedInteger) {
-            return "floatBitsToUint(" + value + ')';
         } else {
             UNREACHABLE();
         }
@@ -541,16 +525,20 @@ private:
             // shader.
             ASSERT(stage == Maxwell3D::Regs::ShaderStage::Vertex);
             return "vec4(0, 0, uintBitsToFloat(gl_InstanceID), uintBitsToFloat(gl_VertexID))";
+        case Attribute::Index::Unknown_63:
+            // TODO(bunnei): Figure out what this is used for. Super Mario Odyssey uses this.
+            LOG_CRITICAL(HW_GPU, "Unhandled input attribute Unknown_63");
+            UNREACHABLE();
+            break;
         default:
             const u32 index{static_cast<u32>(attribute) -
                             static_cast<u32>(Attribute::Index::Attribute_0)};
-            if (attribute >= Attribute::Index::Attribute_0 &&
-                attribute <= Attribute::Index::Attribute_31) {
+            if (attribute >= Attribute::Index::Attribute_0) {
                 declr_input_attribute.insert(attribute);
                 return "input_attribute_" + std::to_string(index);
             }
 
-            LOG_CRITICAL(HW_GPU, "Unhandled input attribute: {}", static_cast<u32>(attribute));
+            LOG_CRITICAL(HW_GPU, "Unhandled input attribute: {}", index);
             UNREACHABLE();
         }
 
@@ -572,7 +560,6 @@ private:
 
             LOG_CRITICAL(HW_GPU, "Unhandled output attribute: {}", index);
             UNREACHABLE();
-            return {};
         }
     }
 
@@ -841,11 +828,7 @@ private:
         ASSERT_MSG(instr.pred.full_pred != Pred::NeverExecute,
                    "NeverExecute predicate not implemented");
 
-        // Some instructions (like SSY) don't have a predicate field, they are always
-        // unconditionally executed.
-        bool can_be_predicated = OpCode::IsPredicatedInstruction(opcode->GetId());
-
-        if (can_be_predicated && instr.pred.pred_index != static_cast<u64>(Pred::UnusedIndex)) {
+        if (instr.pred.pred_index != static_cast<u64>(Pred::UnusedIndex)) {
             shader.AddLine("if (" +
                            GetPredicateCondition(instr.pred.pred_index, instr.negate_pred != 0) +
                            ')');
@@ -1632,99 +1615,6 @@ private:
             }
             break;
         }
-        case OpCode::Type::Xmad: {
-            ASSERT_MSG(!instr.xmad.sign_a, "Unimplemented");
-            ASSERT_MSG(!instr.xmad.sign_b, "Unimplemented");
-
-            std::string op_a{regs.GetRegisterAsInteger(instr.gpr8, 0, instr.xmad.sign_a)};
-            std::string op_b;
-            std::string op_c;
-
-            // TODO(bunnei): Needs to be fixed once op_a or op_b is signed
-            ASSERT_MSG(instr.xmad.sign_a == instr.xmad.sign_b, "Unimplemented");
-            const bool is_signed{instr.xmad.sign_a == 1};
-
-            bool is_merge{};
-            switch (opcode->GetId()) {
-            case OpCode::Id::XMAD_CR: {
-                is_merge = instr.xmad.merge_56;
-                op_b += regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
-                                        instr.xmad.sign_b ? GLSLRegister::Type::Integer
-                                                          : GLSLRegister::Type::UnsignedInteger);
-                op_c += regs.GetRegisterAsInteger(instr.gpr39, 0, is_signed);
-                break;
-            }
-            case OpCode::Id::XMAD_RR: {
-                is_merge = instr.xmad.merge_37;
-                op_b += regs.GetRegisterAsInteger(instr.gpr20, 0, instr.xmad.sign_b);
-                op_c += regs.GetRegisterAsInteger(instr.gpr39, 0, is_signed);
-                break;
-            }
-            case OpCode::Id::XMAD_RC: {
-                op_b += regs.GetRegisterAsInteger(instr.gpr39, 0, instr.xmad.sign_b);
-                op_c += regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
-                                        is_signed ? GLSLRegister::Type::Integer
-                                                  : GLSLRegister::Type::UnsignedInteger);
-                break;
-            }
-            case OpCode::Id::XMAD_IMM: {
-                is_merge = instr.xmad.merge_37;
-                op_b += std::to_string(instr.xmad.imm20_16);
-                op_c += regs.GetRegisterAsInteger(instr.gpr39, 0, is_signed);
-                break;
-            }
-            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled XMAD instruction: {}", opcode->GetName());
-                UNREACHABLE();
-            }
-            }
-
-            // TODO(bunnei): Ensure this is right with signed operands
-            if (instr.xmad.high_a) {
-                op_a = "((" + op_a + ") >> 16)";
-            } else {
-                op_a = "((" + op_a + ") & 0xFFFF)";
-            }
-
-            std::string src2 = '(' + op_b + ')'; // Preserve original source 2
-            if (instr.xmad.high_b) {
-                op_b = '(' + src2 + " >> 16)";
-            } else {
-                op_b = '(' + src2 + " & 0xFFFF)";
-            }
-
-            std::string product = '(' + op_a + " * " + op_b + ')';
-            if (instr.xmad.product_shift_left) {
-                product = '(' + product + " << 16)";
-            }
-
-            switch (instr.xmad.mode) {
-            case Tegra::Shader::XmadMode::None:
-                break;
-            case Tegra::Shader::XmadMode::CLo:
-                op_c = "((" + op_c + ") & 0xFFFF)";
-                break;
-            case Tegra::Shader::XmadMode::CHi:
-                op_c = "((" + op_c + ") >> 16)";
-                break;
-            case Tegra::Shader::XmadMode::CBcc:
-                op_c = "((" + op_c + ") + (" + src2 + "<< 16))";
-                break;
-            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled XMAD mode: {}",
-                             static_cast<u32>(instr.xmad.mode.Value()));
-                UNREACHABLE();
-            }
-            }
-
-            std::string sum{'(' + product + " + " + op_c + ')'};
-            if (is_merge) {
-                sum = "((" + sum + " & 0xFFFF) | (" + src2 + "<< 16))";
-            }
-
-            regs.SetRegisterToInteger(instr.gpr0, is_signed, 0, sum, 1, 1);
-            break;
-        }
         default: {
             switch (opcode->GetId()) {
             case OpCode::Id::EXIT: {
@@ -1762,15 +1652,7 @@ private:
             }
             case OpCode::Id::KIL: {
                 ASSERT(instr.flow.cond == Tegra::Shader::FlowCondition::Always);
-
-                // Enclose "discard" in a conditional, so that GLSL compilation does not complain
-                // about unexecuted instructions that may follow this.
-                shader.AddLine("if (true) {");
-                ++shader.scope;
                 shader.AddLine("discard;");
-                --shader.scope;
-                shader.AddLine("}");
-
                 break;
             }
             case OpCode::Id::BRA: {
@@ -1786,25 +1668,16 @@ private:
                 break;
             }
             case OpCode::Id::SSY: {
-                // The SSY opcode tells the GPU where to re-converge divergent execution paths, it
-                // sets the target of the jump that the SYNC instruction will make. The SSY opcode
-                // has a similar structure to the BRA opcode.
-                ASSERT_MSG(instr.bra.constant_buffer == 0, "Constant buffer SSY is not supported");
-
-                u32 target = offset + instr.bra.GetBranchTarget();
-                shader.AddLine("ssy_target = " + std::to_string(target) + "u;");
+                // The SSY opcode tells the GPU where to re-converge divergent execution paths, we
+                // can ignore this when generating GLSL code.
                 break;
             }
-            case OpCode::Id::SYNC: {
-                // The SYNC opcode jumps to the address previously set by the SSY opcode
+            case OpCode::Id::SYNC:
                 ASSERT(instr.flow.cond == Tegra::Shader::FlowCondition::Always);
-                shader.AddLine("{ jmp_to = ssy_target; break; }");
-                break;
-            }
             case OpCode::Id::DEPBAR: {
-                // TODO(Subv): Find out if we actually have to care about this instruction or if
+                // TODO(Subv): Find out if we actually have to care about these instructions or if
                 // the GLSL compiler takes care of that for us.
-                LOG_WARNING(HW_GPU, "DEPBAR instruction is stubbed");
+                LOG_WARNING(HW_GPU, "DEPBAR/SYNC instruction is stubbed");
                 break;
             }
             default: {
@@ -1818,7 +1691,7 @@ private:
         }
 
         // Close the predicate condition scope.
-        if (can_be_predicated && instr.pred.pred_index != static_cast<u64>(Pred::UnusedIndex)) {
+        if (instr.pred.pred_index != static_cast<u64>(Pred::UnusedIndex)) {
             --shader.scope;
             shader.AddLine('}');
         }
@@ -1869,7 +1742,6 @@ private:
             } else {
                 labels.insert(subroutine.begin);
                 shader.AddLine("uint jmp_to = " + std::to_string(subroutine.begin) + "u;");
-                shader.AddLine("uint ssy_target = 0u;");
                 shader.AddLine("while (true) {");
                 ++shader.scope;
 
@@ -1885,7 +1757,7 @@ private:
                     u32 compile_end = CompileRange(label, next_label);
                     if (compile_end > next_label && compile_end != PROGRAM_END) {
                         // This happens only when there is a label inside a IF/LOOP block
-                        shader.AddLine(" jmp_to = " + std::to_string(compile_end) + "u; break; }");
+                        shader.AddLine("{ jmp_to = " + std::to_string(compile_end) + "u; break; }");
                         labels.emplace(compile_end);
                     }
 

src/video_core/renderer_opengl/gl_state.cpp

@@ -203,6 +203,21 @@ void OpenGLState::Apply() const {
         }
     }
 
+    // Constbuffers
+    for (std::size_t stage = 0; stage < draw.const_buffers.size(); ++stage) {
+        for (std::size_t buffer_id = 0; buffer_id < draw.const_buffers[stage].size(); ++buffer_id) {
+            const auto& current = cur_state.draw.const_buffers[stage][buffer_id];
+            const auto& new_state = draw.const_buffers[stage][buffer_id];
+
+            if (current.enabled != new_state.enabled || current.bindpoint != new_state.bindpoint ||
+                current.ssbo != new_state.ssbo) {
+                if (new_state.enabled) {
+                    glBindBufferBase(GL_UNIFORM_BUFFER, new_state.bindpoint, new_state.ssbo);
+                }
+            }
+        }
+    }
+
     // Framebuffer
     if (draw.read_framebuffer != cur_state.draw.read_framebuffer) {
         glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);

src/video_core/renderer_opengl/gl_state.h

@@ -119,6 +119,12 @@ public:
         GLuint uniform_buffer;   // GL_UNIFORM_BUFFER_BINDING
         GLuint shader_program;   // GL_CURRENT_PROGRAM
         GLuint program_pipeline; // GL_PROGRAM_PIPELINE_BINDING
+        struct ConstBufferConfig {
+            bool enabled = false;
+            GLuint bindpoint;
+            GLuint ssbo;
+        };
+        std::array<std::array<ConstBufferConfig, Regs::MaxConstBuffers>, 5> const_buffers;
     } draw;
 
     struct {

src/video_core/renderer_opengl/gl_stream_buffer.cpp

@@ -9,91 +9,174 @@
 #include "video_core/renderer_opengl/gl_state.h"
 #include "video_core/renderer_opengl/gl_stream_buffer.h"
 
-OGLStreamBuffer::OGLStreamBuffer(GLenum target, GLsizeiptr size, bool prefer_coherent)
-    : gl_target(target), buffer_size(size) {
-    gl_buffer.Create();
-    glBindBuffer(gl_target, gl_buffer.handle);
+class OrphanBuffer : public OGLStreamBuffer {
+public:
+    explicit OrphanBuffer(GLenum target) : OGLStreamBuffer(target) {}
+    ~OrphanBuffer() override;
 
-    GLsizeiptr allocate_size = size;
-    if (target == GL_ARRAY_BUFFER) {
-        // On AMD GPU there is a strange crash in indexed drawing. The crash happens when the buffer
-        // read position is near the end and is an out-of-bound access to the vertex buffer. This is
-        // probably a bug in the driver and is related to the usage of vec3<byte> attributes in the
-        // vertex array. Doubling the allocation size for the vertex buffer seems to avoid the
-        // crash.
-        allocate_size *= 2;
-    }
+private:
+    void Create(size_t size, size_t sync_subdivide) override;
+    void Release() override;
 
-    if (GLAD_GL_ARB_buffer_storage) {
-        persistent = true;
-        coherent = prefer_coherent;
-        GLbitfield flags =
-            GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | (coherent ? GL_MAP_COHERENT_BIT : 0);
-        glBufferStorage(gl_target, allocate_size, nullptr, flags);
-        mapped_ptr = static_cast<u8*>(glMapBufferRange(
-            gl_target, 0, buffer_size, flags | (coherent ? 0 : GL_MAP_FLUSH_EXPLICIT_BIT)));
-    } else {
-        glBufferData(gl_target, allocate_size, nullptr, GL_STREAM_DRAW);
-    }
-}
+    std::pair<u8*, GLintptr> Map(size_t size, size_t alignment) override;
+    void Unmap() override;
 
-OGLStreamBuffer::~OGLStreamBuffer() {
-    if (persistent) {
-        glBindBuffer(gl_target, gl_buffer.handle);
-        glUnmapBuffer(gl_target);
-    }
-    gl_buffer.Release();
+    std::vector<u8> data;
+};
+
+class StorageBuffer : public OGLStreamBuffer {
+public:
+    explicit StorageBuffer(GLenum target) : OGLStreamBuffer(target) {}
+    ~StorageBuffer() override;
+
+private:
+    void Create(size_t size, size_t sync_subdivide) override;
+    void Release() override;
+
+    std::pair<u8*, GLintptr> Map(size_t size, size_t alignment) override;
+    void Unmap() override;
+
+    struct Fence {
+        OGLSync sync;
+        size_t offset;
+    };
+    std::deque<Fence> head;
+    std::deque<Fence> tail;
+
+    u8* mapped_ptr;
+};
+
+OGLStreamBuffer::OGLStreamBuffer(GLenum target) {
+    gl_target = target;
 }
 
 GLuint OGLStreamBuffer::GetHandle() const {
     return gl_buffer.handle;
 }
 
-GLsizeiptr OGLStreamBuffer::GetSize() const {
-    return buffer_size;
+std::unique_ptr<OGLStreamBuffer> OGLStreamBuffer::MakeBuffer(bool storage_buffer, GLenum target) {
+    if (storage_buffer) {
+        return std::make_unique<StorageBuffer>(target);
+    }
+    return std::make_unique<OrphanBuffer>(target);
 }
 
-std::tuple<u8*, GLintptr, bool> OGLStreamBuffer::Map(GLsizeiptr size, GLintptr alignment) {
-    ASSERT(size <= buffer_size);
-    ASSERT(alignment <= buffer_size);
-    mapped_size = size;
+OrphanBuffer::~OrphanBuffer() {
+    Release();
+}
 
-    if (alignment > 0) {
-        buffer_pos = Common::AlignUp<size_t>(buffer_pos, alignment);
+void OrphanBuffer::Create(size_t size, size_t /*sync_subdivide*/) {
+    buffer_pos = 0;
+    buffer_size = size;
+    data.resize(buffer_size);
+
+    if (gl_buffer.handle == 0) {
+        gl_buffer.Create();
+        glBindBuffer(gl_target, gl_buffer.handle);
     }
 
-    bool invalidate = false;
+    glBufferData(gl_target, static_cast<GLsizeiptr>(buffer_size), nullptr, GL_STREAM_DRAW);
+}
+
+void OrphanBuffer::Release() {
+    gl_buffer.Release();
+}
+
+std::pair<u8*, GLintptr> OrphanBuffer::Map(size_t size, size_t alignment) {
+    buffer_pos = Common::AlignUp(buffer_pos, alignment);
+
     if (buffer_pos + size > buffer_size) {
-        buffer_pos = 0;
-        invalidate = true;
+        Create(std::max(buffer_size, size), 0);
+    }
 
-        if (persistent) {
-            glUnmapBuffer(gl_target);
+    mapped_size = size;
+    return std::make_pair(&data[buffer_pos], static_cast<GLintptr>(buffer_pos));
+}
+
+void OrphanBuffer::Unmap() {
+    glBufferSubData(gl_target, static_cast<GLintptr>(buffer_pos),
+                    static_cast<GLsizeiptr>(mapped_size), &data[buffer_pos]);
+    buffer_pos += mapped_size;
+}
+
+StorageBuffer::~StorageBuffer() {
+    Release();
+}
+
+void StorageBuffer::Create(size_t size, size_t sync_subdivide) {
+    if (gl_buffer.handle != 0)
+        return;
+
+    buffer_pos = 0;
+    buffer_size = size;
+    buffer_sync_subdivide = std::max<size_t>(sync_subdivide, 1);
+
+    gl_buffer.Create();
+    glBindBuffer(gl_target, gl_buffer.handle);
+
+    glBufferStorage(gl_target, static_cast<GLsizeiptr>(buffer_size), nullptr,
+                    GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
+    mapped_ptr = reinterpret_cast<u8*>(
+        glMapBufferRange(gl_target, 0, static_cast<GLsizeiptr>(buffer_size),
+                         GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_FLUSH_EXPLICIT_BIT));
+}
+
+void StorageBuffer::Release() {
+    if (gl_buffer.handle == 0)
+        return;
+
+    glUnmapBuffer(gl_target);
+
+    gl_buffer.Release();
+    head.clear();
+    tail.clear();
+}
+
+std::pair<u8*, GLintptr> StorageBuffer::Map(size_t size, size_t alignment) {
+    ASSERT(size <= buffer_size);
+
+    OGLSync sync;
+
+    buffer_pos = Common::AlignUp(buffer_pos, alignment);
+    size_t effective_offset = Common::AlignDown(buffer_pos, buffer_sync_subdivide);
+
+    if (!head.empty() &&
+        (effective_offset > head.back().offset || buffer_pos + size > buffer_size)) {
+        ASSERT(head.back().sync.handle == 0);
+        head.back().sync.Create();
+    }
+
+    if (buffer_pos + size > buffer_size) {
+        if (!tail.empty()) {
+            std::swap(sync, tail.back().sync);
+            tail.clear();
         }
+        std::swap(tail, head);
+        buffer_pos = 0;
+        effective_offset = 0;
     }
 
-    if (invalidate | !persistent) {
-        GLbitfield flags = GL_MAP_WRITE_BIT | (persistent ? GL_MAP_PERSISTENT_BIT : 0) |
-                           (coherent ? GL_MAP_COHERENT_BIT : GL_MAP_FLUSH_EXPLICIT_BIT) |
-                           (invalidate ? GL_MAP_INVALIDATE_BUFFER_BIT : GL_MAP_UNSYNCHRONIZED_BIT);
-        mapped_ptr = static_cast<u8*>(
-            glMapBufferRange(gl_target, buffer_pos, buffer_size - buffer_pos, flags));
-        mapped_offset = buffer_pos;
+    while (!tail.empty() && buffer_pos + size > tail.front().offset) {
+        std::swap(sync, tail.front().sync);
+        tail.pop_front();
     }
 
-    return std::make_tuple(mapped_ptr + buffer_pos - mapped_offset, buffer_pos, invalidate);
+    if (sync.handle != 0) {
+        glClientWaitSync(sync.handle, GL_SYNC_FLUSH_COMMANDS_BIT, GL_TIMEOUT_IGNORED);
+        sync.Release();
+    }
+
+    if (head.empty() || effective_offset > head.back().offset) {
+        head.emplace_back();
+        head.back().offset = effective_offset;
+    }
+
+    mapped_size = size;
+    return std::make_pair(&mapped_ptr[buffer_pos], static_cast<GLintptr>(buffer_pos));
 }
 
-void OGLStreamBuffer::Unmap(GLsizeiptr size) {
-    ASSERT(size <= mapped_size);
-
-    if (!coherent && size > 0) {
-        glFlushMappedBufferRange(gl_target, buffer_pos - mapped_offset, size);
-    }
-
-    if (!persistent) {
-        glUnmapBuffer(gl_target);
-    }
-
-    buffer_pos += size;
+void StorageBuffer::Unmap() {
+    glFlushMappedBufferRange(gl_target, static_cast<GLintptr>(buffer_pos),
+                             static_cast<GLsizeiptr>(mapped_size));
+    buffer_pos += mapped_size;
 }

src/video_core/renderer_opengl/gl_stream_buffer.h

@@ -2,41 +2,35 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <tuple>
+#pragma once
+
+#include <memory>
 #include <glad/glad.h>
 #include "common/common_types.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 
 class OGLStreamBuffer : private NonCopyable {
 public:
-    explicit OGLStreamBuffer(GLenum target, GLsizeiptr size, bool prefer_coherent = false);
-    ~OGLStreamBuffer();
+    explicit OGLStreamBuffer(GLenum target);
+    virtual ~OGLStreamBuffer() = default;
+
+public:
+    static std::unique_ptr<OGLStreamBuffer> MakeBuffer(bool storage_buffer, GLenum target);
+
+    virtual void Create(size_t size, size_t sync_subdivide) = 0;
+    virtual void Release() {}
 
     GLuint GetHandle() const;
-    GLsizeiptr GetSize() const;
 
-    /*
-     * Allocates a linear chunk of memory in the GPU buffer with at least "size" bytes
-     * and the optional alignment requirement.
-     * If the buffer is full, the whole buffer is reallocated which invalidates old chunks.
-     * The return values are the pointer to the new chunk, the offset within the buffer,
-     * and the invalidation flag for previous chunks.
-     * The actual used size must be specified on unmapping the chunk.
-     */
-    std::tuple<u8*, GLintptr, bool> Map(GLsizeiptr size, GLintptr alignment = 0);
+    virtual std::pair<u8*, GLintptr> Map(size_t size, size_t alignment) = 0;
+    virtual void Unmap() = 0;
 
-    void Unmap(GLsizeiptr size);
-
-private:
+protected:
     OGLBuffer gl_buffer;
     GLenum gl_target;
 
-    bool coherent = false;
-    bool persistent = false;
-
-    GLintptr buffer_pos = 0;
-    GLsizeiptr buffer_size = 0;
-    GLintptr mapped_offset = 0;
-    GLsizeiptr mapped_size = 0;
-    u8* mapped_ptr = nullptr;
+    size_t buffer_pos = 0;
+    size_t buffer_size = 0;
+    size_t buffer_sync_subdivide = 0;
+    size_t mapped_size = 0;
 };

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -27,7 +27,6 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
     case Maxwell::VertexAttribute::Type::UnsignedNorm: {
 
         switch (attrib.size) {
-        case Maxwell::VertexAttribute::Size::Size_8:
         case Maxwell::VertexAttribute::Size::Size_8_8:
         case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
             return GL_UNSIGNED_BYTE;
@@ -46,9 +45,6 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
     case Maxwell::VertexAttribute::Type::SignedNorm: {
 
         switch (attrib.size) {
-        case Maxwell::VertexAttribute::Size::Size_32_32_32:
-            return GL_INT;
-        case Maxwell::VertexAttribute::Size::Size_8_8:
         case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
             return GL_BYTE;
         case Maxwell::VertexAttribute::Size::Size_16_16:
@@ -92,8 +88,6 @@ inline GLenum PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
     switch (topology) {
     case Maxwell::PrimitiveTopology::Points:
         return GL_POINTS;
-    case Maxwell::PrimitiveTopology::LineStrip:
-        return GL_LINE_STRIP;
     case Maxwell::PrimitiveTopology::Triangles:
         return GL_TRIANGLES;
     case Maxwell::PrimitiveTopology::TriangleStrip:
@@ -159,61 +153,42 @@ inline GLenum BlendEquation(Maxwell::Blend::Equation equation) {
 inline GLenum BlendFunc(Maxwell::Blend::Factor factor) {
     switch (factor) {
     case Maxwell::Blend::Factor::Zero:
-    case Maxwell::Blend::Factor::ZeroGL:
         return GL_ZERO;
     case Maxwell::Blend::Factor::One:
-    case Maxwell::Blend::Factor::OneGL:
         return GL_ONE;
     case Maxwell::Blend::Factor::SourceColor:
-    case Maxwell::Blend::Factor::SourceColorGL:
         return GL_SRC_COLOR;
     case Maxwell::Blend::Factor::OneMinusSourceColor:
-    case Maxwell::Blend::Factor::OneMinusSourceColorGL:
         return GL_ONE_MINUS_SRC_COLOR;
     case Maxwell::Blend::Factor::SourceAlpha:
-    case Maxwell::Blend::Factor::SourceAlphaGL:
         return GL_SRC_ALPHA;
     case Maxwell::Blend::Factor::OneMinusSourceAlpha:
-    case Maxwell::Blend::Factor::OneMinusSourceAlphaGL:
         return GL_ONE_MINUS_SRC_ALPHA;
     case Maxwell::Blend::Factor::DestAlpha:
-    case Maxwell::Blend::Factor::DestAlphaGL:
         return GL_DST_ALPHA;
     case Maxwell::Blend::Factor::OneMinusDestAlpha:
-    case Maxwell::Blend::Factor::OneMinusDestAlphaGL:
         return GL_ONE_MINUS_DST_ALPHA;
     case Maxwell::Blend::Factor::DestColor:
-    case Maxwell::Blend::Factor::DestColorGL:
         return GL_DST_COLOR;
     case Maxwell::Blend::Factor::OneMinusDestColor:
-    case Maxwell::Blend::Factor::OneMinusDestColorGL:
         return GL_ONE_MINUS_DST_COLOR;
     case Maxwell::Blend::Factor::SourceAlphaSaturate:
-    case Maxwell::Blend::Factor::SourceAlphaSaturateGL:
         return GL_SRC_ALPHA_SATURATE;
     case Maxwell::Blend::Factor::Source1Color:
-    case Maxwell::Blend::Factor::Source1ColorGL:
         return GL_SRC1_COLOR;
     case Maxwell::Blend::Factor::OneMinusSource1Color:
-    case Maxwell::Blend::Factor::OneMinusSource1ColorGL:
         return GL_ONE_MINUS_SRC1_COLOR;
     case Maxwell::Blend::Factor::Source1Alpha:
-    case Maxwell::Blend::Factor::Source1AlphaGL:
         return GL_SRC1_ALPHA;
     case Maxwell::Blend::Factor::OneMinusSource1Alpha:
-    case Maxwell::Blend::Factor::OneMinusSource1AlphaGL:
         return GL_ONE_MINUS_SRC1_ALPHA;
     case Maxwell::Blend::Factor::ConstantColor:
-    case Maxwell::Blend::Factor::ConstantColorGL:
         return GL_CONSTANT_COLOR;
     case Maxwell::Blend::Factor::OneMinusConstantColor:
-    case Maxwell::Blend::Factor::OneMinusConstantColorGL:
         return GL_ONE_MINUS_CONSTANT_COLOR;
     case Maxwell::Blend::Factor::ConstantAlpha:
-    case Maxwell::Blend::Factor::ConstantAlphaGL:
         return GL_CONSTANT_ALPHA;
     case Maxwell::Blend::Factor::OneMinusConstantAlpha:
-    case Maxwell::Blend::Factor::OneMinusConstantAlphaGL:
         return GL_ONE_MINUS_CONSTANT_ALPHA;
     }
     LOG_CRITICAL(Render_OpenGL, "Unimplemented blend factor={}", static_cast<u32>(factor));

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -18,6 +18,7 @@
 #include "core/tracer/recorder.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
 #include "video_core/utils.h"
+#include "video_core/video_core.h"
 
 static const char vertex_shader[] = R"(
 #version 150 core
@@ -91,8 +92,7 @@ static std::array<GLfloat, 3 * 2> MakeOrthographicMatrix(const float width, cons
     return matrix;
 }
 
-ScopeAcquireGLContext::ScopeAcquireGLContext(Core::Frontend::EmuWindow& emu_window_)
-    : emu_window{emu_window_} {
+ScopeAcquireGLContext::ScopeAcquireGLContext(EmuWindow& emu_window_) : emu_window{emu_window_} {
     if (Settings::values.use_multi_core) {
         emu_window.MakeCurrent();
     }
@@ -103,9 +103,7 @@ ScopeAcquireGLContext::~ScopeAcquireGLContext() {
     }
 }
 
-RendererOpenGL::RendererOpenGL(Core::Frontend::EmuWindow& window)
-    : VideoCore::RendererBase{window} {}
-
+RendererOpenGL::RendererOpenGL(EmuWindow& window) : VideoCore::RendererBase{window} {}
 RendererOpenGL::~RendererOpenGL() = default;
 
 /// Swap buffers (render frame)

src/video_core/renderer_opengl/renderer_opengl.h

@@ -12,9 +12,7 @@
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_state.h"
 
-namespace Core::Frontend {
 class EmuWindow;
-}
 
 /// Structure used for storing information about the textures for the Switch screen
 struct TextureInfo {
@@ -36,16 +34,16 @@ struct ScreenInfo {
 /// Helper class to acquire/release OpenGL context within a given scope
 class ScopeAcquireGLContext : NonCopyable {
 public:
-    explicit ScopeAcquireGLContext(Core::Frontend::EmuWindow& window);
+    explicit ScopeAcquireGLContext(EmuWindow& window);
     ~ScopeAcquireGLContext();
 
 private:
-    Core::Frontend::EmuWindow& emu_window;
+    EmuWindow& emu_window;
 };
 
 class RendererOpenGL : public VideoCore::RendererBase {
 public:
-    explicit RendererOpenGL(Core::Frontend::EmuWindow& window);
+    explicit RendererOpenGL(EmuWindow& window);
     ~RendererOpenGL() override;
 
     /// Swap buffers (render frame)

src/video_core/textures/decoders.cpp

@@ -86,11 +86,88 @@ u32 BytesPerPixel(TextureFormat format) {
     }
 }
 
-std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size, u32 bytes_per_pixel, u32 width,
-                                 u32 height, u32 block_height) {
+static u32 DepthBytesPerPixel(DepthFormat format) {
+    switch (format) {
+    case DepthFormat::Z16_UNORM:
+        return 2;
+    case DepthFormat::S8_Z24_UNORM:
+    case DepthFormat::Z24_S8_UNORM:
+    case DepthFormat::Z32_FLOAT:
+        return 4;
+    case DepthFormat::Z32_S8_X24_FLOAT:
+        return 8;
+    default:
+        UNIMPLEMENTED_MSG("Format not implemented");
+        break;
+    }
+}
+
+std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width, u32 height,
+                                 u32 block_height) {
+    u8* data = Memory::GetPointer(address);
+    u32 bytes_per_pixel = BytesPerPixel(format);
+
     std::vector<u8> unswizzled_data(width * height * bytes_per_pixel);
-    CopySwizzledData(width / tile_size, height / tile_size, bytes_per_pixel, bytes_per_pixel,
-                     Memory::GetPointer(address), unswizzled_data.data(), true, block_height);
+
+    switch (format) {
+    case TextureFormat::DXT1:
+    case TextureFormat::DXT23:
+    case TextureFormat::DXT45:
+    case TextureFormat::DXN1:
+    case TextureFormat::DXN2:
+    case TextureFormat::BC7U:
+        // In the DXT and DXN formats, each 4x4 tile is swizzled instead of just individual pixel
+        // values.
+        CopySwizzledData(width / 4, height / 4, bytes_per_pixel, bytes_per_pixel, data,
+                         unswizzled_data.data(), true, block_height);
+        break;
+    case TextureFormat::A8R8G8B8:
+    case TextureFormat::A2B10G10R10:
+    case TextureFormat::A1B5G5R5:
+    case TextureFormat::B5G6R5:
+    case TextureFormat::R8:
+    case TextureFormat::G8R8:
+    case TextureFormat::R16_G16_B16_A16:
+    case TextureFormat::R32_G32_B32_A32:
+    case TextureFormat::R32_G32:
+    case TextureFormat::R32:
+    case TextureFormat::R16:
+    case TextureFormat::R16_G16:
+    case TextureFormat::BF10GF11RF11:
+    case TextureFormat::ASTC_2D_4X4:
+    case TextureFormat::R32_G32_B32:
+        CopySwizzledData(width, height, bytes_per_pixel, bytes_per_pixel, data,
+                         unswizzled_data.data(), true, block_height);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Format not implemented");
+        break;
+    }
+
+    return unswizzled_data;
+}
+
+std::vector<u8> UnswizzleDepthTexture(VAddr address, DepthFormat format, u32 width, u32 height,
+                                      u32 block_height) {
+    u8* data = Memory::GetPointer(address);
+    u32 bytes_per_pixel = DepthBytesPerPixel(format);
+
+    std::vector<u8> unswizzled_data(width * height * bytes_per_pixel);
+
+    switch (format) {
+    case DepthFormat::Z16_UNORM:
+    case DepthFormat::S8_Z24_UNORM:
+    case DepthFormat::Z24_S8_UNORM:
+    case DepthFormat::Z32_FLOAT:
+    case DepthFormat::Z32_S8_X24_FLOAT:
+        CopySwizzledData(width, height, bytes_per_pixel, bytes_per_pixel, data,
+                         unswizzled_data.data(), true, block_height);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Format not implemented");
+        break;
+    }
+
     return unswizzled_data;
 }
 

src/video_core/textures/decoders.h

@@ -13,8 +13,8 @@ namespace Tegra::Texture {
 /**
  * Unswizzles a swizzled texture without changing its format.
  */
-std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size, u32 bytes_per_pixel, u32 width,
-                                 u32 height, u32 block_height = TICEntry::DefaultBlockHeight);
+std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width, u32 height,
+                                 u32 block_height = TICEntry::DefaultBlockHeight);
 
 /**
  * Unswizzles a swizzled depth texture without changing its format.

src/video_core/video_core.cpp

@@ -9,7 +9,9 @@
 
 namespace VideoCore {
 
-std::unique_ptr<RendererBase> CreateRenderer(Core::Frontend::EmuWindow& emu_window) {
+std::atomic<bool> g_toggle_framelimit_enabled;
+
+std::unique_ptr<RendererBase> CreateRenderer(EmuWindow& emu_window) {
     return std::make_unique<RendererOpenGL>(emu_window);
 }
 

src/video_core/video_core.h

@@ -4,22 +4,27 @@
 
 #pragma once
 
+#include <atomic>
 #include <memory>
 
-namespace Core::Frontend {
 class EmuWindow;
-}
 
 namespace VideoCore {
 
 class RendererBase;
 
+enum class Renderer { Software, OpenGL };
+
+// TODO: Wrap these in a user settings struct along with any other graphics settings (often set from
+// qt ui)
+extern std::atomic<bool> g_toggle_framelimit_enabled;
+
 /**
  * Creates a renderer instance.
  *
  * @note The returned renderer instance is simply allocated. Its Init()
  *       function still needs to be called to fully complete its setup.
  */
-std::unique_ptr<RendererBase> CreateRenderer(Core::Frontend::EmuWindow& emu_window);
+std::unique_ptr<RendererBase> CreateRenderer(EmuWindow& emu_window);
 
 } // namespace VideoCore

src/yuzu/bootmanager.h

@@ -101,7 +101,7 @@ signals:
     void ErrorThrown(Core::System::ResultStatus, std::string);
 };
 
-class GRenderWindow : public QWidget, public Core::Frontend::EmuWindow {
+class GRenderWindow : public QWidget, public EmuWindow {
     Q_OBJECT
 
 public:

src/yuzu/debugger/graphics/graphics_surface.cpp

@@ -383,10 +383,8 @@ void GraphicsSurfaceWidget::OnUpdate() {
     QImage decoded_image(surface_width, surface_height, QImage::Format_ARGB32);
     boost::optional<VAddr> address = gpu.memory_manager->GpuToCpuAddress(surface_address);
 
-    // TODO(bunnei): Will not work with BCn formats that swizzle 4x4 tiles.
-    // Needs to be fixed if we plan to use this feature more, otherwise we may remove it.
-    auto unswizzled_data = Tegra::Texture::UnswizzleTexture(
-        *address, 1, Tegra::Texture::BytesPerPixel(surface_format), surface_width, surface_height);
+    auto unswizzled_data =
+        Tegra::Texture::UnswizzleTexture(*address, surface_format, surface_width, surface_height);
 
     auto texture_data = Tegra::Texture::DecodeTexture(unswizzled_data, surface_format,
                                                       surface_width, surface_height);

src/yuzu/game_list.cpp

@@ -453,7 +453,10 @@ void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsign
             std::string name = " ";
             const auto res3 = loader->ReadTitle(name);
 
-            if (res1 != Loader::ResultStatus::Success && res3 != Loader::ResultStatus::Success &&
+            if ((res1 == Loader::ResultStatus::ErrorNotUsed ||
+                 res1 == Loader::ResultStatus::ErrorNotImplemented) &&
+                (res3 == Loader::ResultStatus::ErrorNotUsed ||
+                 res3 == Loader::ResultStatus::ErrorNotImplemented) &&
                 res2 == Loader::ResultStatus::Success) {
                 // Use from metadata pool.
                 if (nca_control_map.find(program_id) != nca_control_map.end()) {

src/yuzu/game_list_p.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <array>
 #include <atomic>
 #include <utility>
 #include <QImage>
@@ -40,6 +39,7 @@ public:
  * If this class receives valid SMDH data, it will also display game icons and titles.
  */
 class GameListItemPath : public GameListItem {
+
 public:
     static const int FullPathRole = Qt::UserRole + 1;
     static const int TitleRole = Qt::UserRole + 2;
@@ -48,18 +48,18 @@ public:
 
     GameListItemPath() = default;
     GameListItemPath(const QString& game_path, const std::vector<u8>& picture_data,
-                     const QString& game_name, const QString& game_type, u64 program_id) {
+                     const QString& game_name, const QString& game_type, u64 program_id)
+        : GameListItem() {
         setData(game_path, FullPathRole);
         setData(game_name, TitleRole);
         setData(qulonglong(program_id), ProgramIdRole);
         setData(game_type, FileTypeRole);
 
-        const u32 size = UISettings::values.icon_size;
-
         QPixmap picture;
-        if (!picture.loadFromData(picture_data.data(), static_cast<u32>(picture_data.size()))) {
+        u32 size = UISettings::values.icon_size;
+        if (!picture.loadFromData(picture_data.data(), picture_data.size()))
             picture = GetDefaultIcon(size);
-        }
+
         picture = picture.scaled(size, size);
 
         setData(picture, Qt::DecorationRole);
@@ -70,16 +70,17 @@ public:
             std::string filename;
             Common::SplitPath(data(FullPathRole).toString().toStdString(), nullptr, &filename,
                               nullptr);
+            QString title = data(TitleRole).toString();
 
-            const std::array<QString, 4> row_data{{
+            std::vector<QString> row_data{
                 QString::fromStdString(filename),
                 data(FileTypeRole).toString(),
                 QString::fromStdString(fmt::format("0x{:016X}", data(ProgramIdRole).toULongLong())),
                 data(TitleRole).toString(),
-            }};
+            };
 
-            const auto& row1 = row_data.at(UISettings::values.row_1_text_id);
-            const auto& row2 = row_data.at(UISettings::values.row_2_text_id);
+            auto row1 = row_data.at(UISettings::values.row_1_text_id);
+            auto row2 = row_data.at(UISettings::values.row_2_text_id);
 
             if (row1.isEmpty() || row1 == row2)
                 return row2;
@@ -87,9 +88,9 @@ public:
                 return row1;
 
             return row1 + "\n    " + row2;
+        } else {
+            return GameListItem::data(role);
         }
-
-        return GameListItem::data(role);
     }
 };
 

src/yuzu/main.cpp

@@ -424,11 +424,67 @@ bool GMainWindow::LoadROM(const QString& filename) {
             QMessageBox::critical(this, tr("Error while loading ROM!"),
                                   tr("The ROM format is not supported."));
             break;
+        case Core::System::ResultStatus::ErrorUnsupportedArch:
+            LOG_CRITICAL(Frontend, "Unsupported architecture detected!", filename.toStdString());
+            QMessageBox::critical(this, tr("Error while loading ROM!"),
+                                  tr("The ROM uses currently unusable 32-bit architecture"));
+            break;
         case Core::System::ResultStatus::ErrorSystemMode:
             LOG_CRITICAL(Frontend, "Failed to load ROM!");
             QMessageBox::critical(this, tr("Error while loading ROM!"),
                                   tr("Could not determine the system mode."));
             break;
+
+        case Core::System::ResultStatus::ErrorLoader_ErrorMissingKeys: {
+            const auto reg_found = Core::Crypto::KeyManager::KeyFileExists(false);
+            const auto title_found = Core::Crypto::KeyManager::KeyFileExists(true);
+
+            std::string file_text;
+
+            if (!reg_found && !title_found) {
+                file_text = "A proper key file (prod.keys, dev.keys, or title.keys) could not be "
+                            "found. You will need to dump your keys from your switch to continue.";
+            } else if (reg_found && title_found) {
+                file_text =
+                    "Both key files were found in your config directory, but the correct key could"
+                    "not be found. You may be missing a titlekey or general key, depending on "
+                    "the game.";
+            } else if (reg_found) {
+                file_text =
+                    "The regular keys file (prod.keys/dev.keys) was found in your config, but the "
+                    "titlekeys file (title.keys) was not. You are either missing the correct "
+                    "titlekey or missing a general key required to decrypt the game.";
+            } else {
+                file_text = "The title keys file (title.keys) was found in your config, but "
+                            "the regular keys file (prod.keys/dev.keys) was not. Unfortunately, "
+                            "having the titlekey is not enough, you need additional general keys "
+                            "to properly decrypt the game. You should double-check to make sure "
+                            "your keys are correct.";
+            }
+
+            QMessageBox::critical(
+                this, tr("Error while loading ROM!"),
+                tr(("The game you are trying to load is encrypted and the required keys to load "
+                    "the game could not be found in your configuration. " +
+                    file_text + " Please refer to the yuzu wiki for help.")
+                       .c_str()));
+            break;
+        }
+        case Core::System::ResultStatus::ErrorLoader_ErrorDecrypting: {
+            QMessageBox::critical(
+                this, tr("Error while loading ROM!"),
+                tr("There was a general error while decrypting the game. This means that the keys "
+                   "necessary were found, but were either incorrect, the game itself was not a "
+                   "valid game or the game uses an unhandled cryptographic scheme. Please double "
+                   "check that you have the correct "
+                   "keys."));
+            break;
+        }
+        case Core::System::ResultStatus::ErrorLoader_ErrorInvalidFormat:
+            QMessageBox::critical(this, tr("Error while loading ROM!"),
+                                  tr("The ROM format is not supported."));
+            break;
+
         case Core::System::ResultStatus::ErrorVideoCore:
             QMessageBox::critical(
                 this, tr("An error occurred initializing the video core."),
@@ -443,23 +499,9 @@ bool GMainWindow::LoadROM(const QString& filename) {
             break;
 
         default:
-            if (static_cast<u32>(result) >
-                static_cast<u32>(Core::System::ResultStatus::ErrorLoader)) {
-                LOG_CRITICAL(Frontend, "Failed to load ROM!");
-                const u16 loader_id = static_cast<u16>(Core::System::ResultStatus::ErrorLoader);
-                const u16 error_id = static_cast<u16>(result) - loader_id;
-                QMessageBox::critical(
-                    this, tr("Error while loading ROM!"),
-                    QString::fromStdString(fmt::format(
-                        "While attempting to load the ROM requested, an error occured. Please "
-                        "refer to the yuzu wiki for more information or the yuzu discord for "
-                        "additional help.\n\nError Code: {:04X}-{:04X}\nError Description: {}",
-                        loader_id, error_id, Loader::GetMessageForResultStatus(error_id))));
-            } else {
-                QMessageBox::critical(
-                    this, tr("Error while loading ROM!"),
-                    tr("An unknown error occurred. Please see the log for more details."));
-            }
+            QMessageBox::critical(
+                this, tr("Error while loading ROM!"),
+                tr("An unknown error occurred. Please see the log for more details."));
             break;
         }
         return false;

src/yuzu_cmd/emu_window/emu_window_sdl2.h

@@ -10,7 +10,7 @@
 
 struct SDL_Window;
 
-class EmuWindow_SDL2 : public Core::Frontend::EmuWindow {
+class EmuWindow_SDL2 : public EmuWindow {
 public:
     explicit EmuWindow_SDL2(bool fullscreen);
     ~EmuWindow_SDL2();

src/yuzu_cmd/yuzu.cpp

@@ -174,6 +174,19 @@ int main(int argc, char** argv) {
     case Core::System::ResultStatus::ErrorLoader:
         LOG_CRITICAL(Frontend, "Failed to load ROM!");
         return -1;
+    case Core::System::ResultStatus::ErrorLoader_ErrorMissingKeys:
+        LOG_CRITICAL(Frontend, "The game you are trying to load is encrypted and the keys required "
+                               "could not be found. Please refer to the yuzu wiki for help");
+        return -1;
+    case Core::System::ResultStatus::ErrorLoader_ErrorDecrypting:
+        LOG_CRITICAL(Frontend, "The game you are trying to load is encrypted and there was a "
+                               "general error while decrypting. This could mean that the keys are "
+                               "incorrect, game is invalid or game uses an unsupported method of "
+                               "crypto. Please double-check your keys");
+        return -1;
+    case Core::System::ResultStatus::ErrorLoader_ErrorInvalidFormat:
+        LOG_CRITICAL(Frontend, "Error while loading ROM: The ROM format is not supported.");
+        return -1;
     case Core::System::ResultStatus::ErrorNotInitialized:
         LOG_CRITICAL(Frontend, "CPUCore not initialized");
         return -1;
@@ -185,17 +198,6 @@ int main(int argc, char** argv) {
         return -1;
     case Core::System::ResultStatus::Success:
         break; // Expected case
-    default:
-        if (static_cast<u32>(load_result) >
-            static_cast<u32>(Core::System::ResultStatus::ErrorLoader)) {
-            const u16 loader_id = static_cast<u16>(Core::System::ResultStatus::ErrorLoader);
-            const u16 error_id = static_cast<u16>(load_result) - loader_id;
-            LOG_CRITICAL(Frontend,
-                         "While attempting to load the ROM requested, an error occured. Please "
-                         "refer to the yuzu wiki for more information or the yuzu discord for "
-                         "additional help.\n\nError Code: {:04X}-{:04X}\nError Description: {}",
-                         loader_id, error_id, Loader::GetMessageForResultStatus(error_id));
-        }
     }
 
     Core::Telemetry().AddField(Telemetry::FieldType::App, "Frontend", "SDL");