gl_rasterizer: Implement stencil test.

- Used by Splatoon 2.

src/audio_core/algorithm/filter.cpp

@@ -46,7 +46,7 @@ void Filter::Process(std::vector<s16>& signal) {
             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);
+            signal[i * 2 + ch] = static_cast<s16>(std::clamp(out[0][ch], -32768.0, 32767.0));
         }
     }
 }

src/common/bit_field.h

@@ -178,8 +178,7 @@ public:
         return ExtractValue(storage);
     }
 
-    // TODO: we may want to change this to explicit operator bool() if it's bug-free in VS2015
-    constexpr FORCE_INLINE bool ToBool() const {
+    constexpr explicit operator bool() const {
         return Value() != 0;
     }
 

src/common/logging/text_formatter.cpp

@@ -42,7 +42,7 @@ void PrintColoredMessage(const Entry& entry) {
         return;
     }
 
-    CONSOLE_SCREEN_BUFFER_INFO original_info = {0};
+    CONSOLE_SCREEN_BUFFER_INFO original_info = {};
     GetConsoleScreenBufferInfo(console_handle, &original_info);
 
     WORD color = 0;

src/core/file_sys/nca_metadata.h

@@ -7,6 +7,7 @@
 #include <cstring>
 #include <memory>
 #include <vector>
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/file_sys/vfs.h"

src/core/file_sys/romfs_factory.cpp

@@ -6,15 +6,18 @@
 #include <memory>
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
+#include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs_factory.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/loader/loader.h"
 
 namespace FileSys {
 
 RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     // Load the RomFS from the app
-    if (Loader::ResultStatus::Success != app_loader.ReadRomFS(file)) {
+    if (app_loader.ReadRomFS(file) != Loader::ResultStatus::Success) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
     }
 }

src/core/file_sys/romfs_factory.h

@@ -6,11 +6,17 @@
 
 #include <memory>
 #include "common/common_types.h"
+#include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
-#include "core/loader/loader.h"
+
+namespace Loader {
+class AppLoader;
+} // namespace Loader
 
 namespace FileSys {
 
+enum class ContentRecordType : u8;
+
 enum class StorageId : u8 {
     None = 0,
     Host = 1,

src/core/file_sys/savedata_factory.cpp

@@ -73,7 +73,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescr
 }
 
 std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
-                                         u128 user_id, u64 save_id) const {
+                                         u128 user_id, u64 save_id) {
     // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
     // be interpreted as the title id of the current process.
     if (type == SaveDataType::SaveData && title_id == 0)

src/core/file_sys/savedata_factory.h

@@ -49,11 +49,11 @@ public:
 
     ResultVal<VirtualDir> Open(SaveDataSpaceId space, SaveDataDescriptor meta);
 
+    static std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
+                                   u128 user_id, u64 save_id);
+
 private:
     VirtualDir dir;
-
-    std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id,
-                            u64 save_id) const;
 };
 
 } // namespace FileSys

src/core/file_sys/sdmc_factory.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <memory>
-#include "core/core.h"
 #include "core/file_sys/sdmc_factory.h"
 
 namespace FileSys {

src/core/file_sys/sdmc_factory.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
 namespace FileSys {

src/core/file_sys/vfs.cpp

@@ -8,6 +8,7 @@
 #include "common/common_paths.h"
 #include "common/file_util.h"
 #include "common/logging/backend.h"
+#include "core/file_sys/mode.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {

src/core/file_sys/vfs.h

@@ -9,9 +9,8 @@
 #include <string_view>
 #include <type_traits>
 #include <vector>
-#include "boost/optional.hpp"
+#include <boost/optional.hpp>
 #include "common/common_types.h"
-#include "core/file_sys/mode.h"
 
 namespace FileSys {
 
@@ -19,6 +18,8 @@ class VfsDirectory;
 class VfsFile;
 class VfsFilesystem;
 
+enum class Mode : u32;
+
 // Convenience typedefs to use Vfs* interfaces
 using VirtualFilesystem = std::shared_ptr<VfsFilesystem>;
 using VirtualDir = std::shared_ptr<VfsDirectory>;

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

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
 #include <cinttypes>
 #include <stack>
 #include "core/core.h"
@@ -625,16 +626,16 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
 }
 
 void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
-    constexpr u8 data[0x88] = {
+    constexpr std::array<u8, 0x88> data{{
         0xca, 0x97, 0x94, 0xc7, // Magic
         1,    0,    0,    0,    // IsAccountSelected (bool)
         1,    0,    0,    0,    // User Id (word 0)
         0,    0,    0,    0,    // User Id (word 1)
         0,    0,    0,    0,    // User Id (word 2)
         0,    0,    0,    0     // User Id (word 3)
-    };
+    }};
 
-    std::vector<u8> buffer(data, data + sizeof(data));
+    std::vector<u8> buffer(data.begin(), data.end());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
 

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

@@ -7,12 +7,14 @@
 #include "common/assert.h"
 #include "common/file_util.h"
 #include "core/core.h"
+#include "core/file_sys/bis_factory.h"
 #include "core/file_sys/errors.h"
+#include "core/file_sys/mode.h"
+#include "core/file_sys/romfs_factory.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_offset.h"
-#include "core/file_sys/vfs_real.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_ldr.h"
 #include "core/hle/service/filesystem/fsp_pr.h"

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

@@ -6,14 +6,24 @@
 
 #include <memory>
 #include "common/common_types.h"
-#include "core/file_sys/bis_factory.h"
 #include "core/file_sys/directory.h"
-#include "core/file_sys/mode.h"
-#include "core/file_sys/romfs_factory.h"
-#include "core/file_sys/savedata_factory.h"
-#include "core/file_sys/sdmc_factory.h"
 #include "core/hle/result.h"
 
+namespace FileSys {
+class BISFactory;
+class RegisteredCache;
+class RomFSFactory;
+class SaveDataFactory;
+class SDMCFactory;
+
+enum class ContentRecordType : u8;
+enum class Mode : u32;
+enum class SaveDataSpaceId : u8;
+enum class StorageId : u8;
+
+struct SaveDataDescriptor;
+} // namespace FileSys
+
 namespace Service {
 
 namespace SM {

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

@@ -13,9 +13,12 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-#include "core/core.h"
 #include "core/file_sys/directory.h"
 #include "core/file_sys/errors.h"
+#include "core/file_sys/mode.h"
+#include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/savedata_factory.h"
+#include "core/file_sys/vfs.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/filesystem/filesystem.h"

src/core/hle/service/ns/pl_u.cpp

@@ -5,31 +5,98 @@
 #include "common/common_paths.h"
 #include "common/file_util.h"
 #include "core/core.h"
+#include "core/file_sys/bis_factory.h"
+#include "core/file_sys/romfs.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ns/pl_u.h"
 
 namespace Service::NS {
 
+enum class FontArchives : u64 {
+    Extension = 0x0100000000000810,
+    Standard = 0x0100000000000811,
+    Korean = 0x0100000000000812,
+    ChineseTraditional = 0x0100000000000813,
+    ChineseSimple = 0x0100000000000814,
+};
+
 struct FontRegion {
     u32 offset;
     u32 size;
 };
 
+static constexpr std::array<std::pair<FontArchives, const char*>, 7> SHARED_FONTS{
+    std::make_pair(FontArchives::Standard, "nintendo_udsg-r_std_003.bfttf"),
+    std::make_pair(FontArchives::ChineseSimple, "nintendo_udsg-r_org_zh-cn_003.bfttf"),
+    std::make_pair(FontArchives::ChineseSimple, "nintendo_udsg-r_ext_zh-cn_003.bfttf"),
+    std::make_pair(FontArchives::ChineseTraditional, "nintendo_udjxh-db_zh-tw_003.bfttf"),
+    std::make_pair(FontArchives::Korean, "nintendo_udsg-r_ko_003.bfttf"),
+    std::make_pair(FontArchives::Extension, "nintendo_ext_003.bfttf"),
+    std::make_pair(FontArchives::Extension, "nintendo_ext2_003.bfttf")};
+
 // The below data is specific to shared font data dumped from Switch on f/w 2.2
 // Virtual address and offsets/sizes likely will vary by dump
 static constexpr VAddr SHARED_FONT_MEM_VADDR{0x00000009d3016000ULL};
+static constexpr u32 EXPECTED_RESULT{
+    0x7f9a0218}; // What we expect the decrypted bfttf first 4 bytes to be
+static constexpr u32 EXPECTED_MAGIC{
+    0x36f81a1e}; // What we expect the encrypted bfttf first 4 bytes to be
 static constexpr u64 SHARED_FONT_MEM_SIZE{0x1100000};
-static constexpr std::array<FontRegion, 6> SHARED_FONT_REGIONS{
-    FontRegion{0x00000008, 0x001fe764}, FontRegion{0x001fe774, 0x00773e58},
-    FontRegion{0x009725d4, 0x0001aca8}, FontRegion{0x0098d284, 0x00369cec},
-    FontRegion{0x00cf6f78, 0x0039b858}, FontRegion{0x010927d8, 0x00019e80},
-};
+static constexpr FontRegion EMPTY_REGION{0, 0};
+std::vector<FontRegion>
+    SHARED_FONT_REGIONS{}; // Automatically populated based on shared_fonts dump or system archives
+
+const FontRegion& GetSharedFontRegion(size_t index) {
+    if (index >= SHARED_FONT_REGIONS.size() || SHARED_FONT_REGIONS.empty()) {
+        // No font fallback
+        return EMPTY_REGION;
+    }
+    return SHARED_FONT_REGIONS.at(index);
+}
 
 enum class LoadState : u32 {
     Loading = 0,
     Done = 1,
 };
 
+void DecryptSharedFont(const std::vector<u32>& input, std::vector<u8>& output, size_t& offset) {
+    ASSERT_MSG(offset + (input.size() * sizeof(u32)) < SHARED_FONT_MEM_SIZE,
+               "Shared fonts exceeds 17mb!");
+    ASSERT_MSG(input[0] == EXPECTED_MAGIC, "Failed to derive key, unexpected magic number");
+
+    const u32 KEY = input[0] ^ EXPECTED_RESULT; // Derive key using an inverse xor
+    std::vector<u32> transformed_font(input.size());
+    // TODO(ogniK): Figure out a better way to do this
+    std::transform(input.begin(), input.end(), transformed_font.begin(),
+                   [&KEY](u32 font_data) { return Common::swap32(font_data ^ KEY); });
+    transformed_font[1] = Common::swap32(transformed_font[1]) ^ KEY; // "re-encrypt" the size
+    std::memcpy(output.data() + offset, transformed_font.data(),
+                transformed_font.size() * sizeof(u32));
+    offset += transformed_font.size() * sizeof(u32);
+}
+
+static u32 GetU32Swapped(const u8* data) {
+    u32 value;
+    std::memcpy(&value, data, sizeof(value));
+    return Common::swap32(value); // Helper function to make BuildSharedFontsRawRegions a bit nicer
+}
+
+void BuildSharedFontsRawRegions(const std::vector<u8>& input) {
+    unsigned cur_offset = 0; // As we can derive the xor key we can just populate the offsets based
+                             // on the shared memory dump
+    for (size_t i = 0; i < SHARED_FONTS.size(); i++) {
+        // Out of shared fonts/Invalid font
+        if (GetU32Swapped(input.data() + cur_offset) != EXPECTED_RESULT)
+            break;
+        const u32 KEY = GetU32Swapped(input.data() + cur_offset) ^
+                        EXPECTED_MAGIC; // Derive key withing inverse xor
+        const u32 SIZE = GetU32Swapped(input.data() + cur_offset + 4) ^ KEY;
+        SHARED_FONT_REGIONS.push_back(FontRegion{cur_offset + 8, SIZE});
+        cur_offset += SIZE + 8;
+    }
+}
+
 PL_U::PL_U() : ServiceFramework("pl:u") {
     static const FunctionInfo functions[] = {
         {0, &PL_U::RequestLoad, "RequestLoad"},
@@ -40,26 +107,78 @@ PL_U::PL_U() : ServiceFramework("pl:u") {
         {5, &PL_U::GetSharedFontInOrderOfPriority, "GetSharedFontInOrderOfPriority"},
     };
     RegisterHandlers(functions);
-
     // Attempt to load shared font data from disk
-    const std::string filepath{FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir) + SHARED_FONT};
-    FileUtil::CreateFullPath(filepath); // Create path if not already created
-    FileUtil::IOFile file(filepath, "rb");
-
-    shared_font = std::make_shared<std::vector<u8>>(SHARED_FONT_MEM_SIZE);
-    if (file.IsOpen()) {
-        // Read shared font data
-        ASSERT(file.GetSize() == SHARED_FONT_MEM_SIZE);
-        file.ReadBytes(shared_font->data(), shared_font->size());
+    const auto nand = FileSystem::GetSystemNANDContents();
+    // Rebuild shared fonts from data ncas
+    if (nand->HasEntry(static_cast<u64>(FontArchives::Standard),
+                       FileSys::ContentRecordType::Data)) {
+        size_t offset = 0;
+        shared_font = std::make_shared<std::vector<u8>>(SHARED_FONT_MEM_SIZE);
+        for (auto font : SHARED_FONTS) {
+            const auto nca =
+                nand->GetEntry(static_cast<u64>(font.first), FileSys::ContentRecordType::Data);
+            if (!nca) {
+                LOG_ERROR(Service_NS, "Failed to find {:016X}! Skipping",
+                          static_cast<u64>(font.first));
+                continue;
+            }
+            const auto romfs = nca->GetRomFS();
+            if (!romfs) {
+                LOG_ERROR(Service_NS, "{:016X} has no RomFS! Skipping",
+                          static_cast<u64>(font.first));
+                continue;
+            }
+            const auto extracted_romfs = FileSys::ExtractRomFS(romfs);
+            if (!extracted_romfs) {
+                LOG_ERROR(Service_NS, "Failed to extract RomFS for {:016X}! Skipping",
+                          static_cast<u64>(font.first));
+                continue;
+            }
+            const auto font_fp = extracted_romfs->GetFile(font.second);
+            if (!font_fp) {
+                LOG_ERROR(Service_NS, "{:016X} has no file \"{}\"! Skipping",
+                          static_cast<u64>(font.first), font.second);
+                continue;
+            }
+            std::vector<u32> font_data_u32(font_fp->GetSize() / sizeof(u32));
+            font_fp->ReadBytes<u32>(font_data_u32.data(), font_fp->GetSize());
+            // We need to be BigEndian as u32s for the xor encryption
+            std::transform(font_data_u32.begin(), font_data_u32.end(), font_data_u32.begin(),
+                           Common::swap32);
+            FontRegion region{
+                static_cast<u32>(offset + 8),
+                static_cast<u32>((font_data_u32.size() * sizeof(u32)) -
+                                 8)}; // Font offset and size do not account for the header
+            DecryptSharedFont(font_data_u32, *shared_font, offset);
+            SHARED_FONT_REGIONS.push_back(region);
+        }
     } else {
-        LOG_WARNING(Service_NS, "Unable to load shared font: {}", filepath);
+        const std::string filepath{FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir) +
+                                   SHARED_FONT};
+        // Create path if not already created
+        if (!FileUtil::CreateFullPath(filepath)) {
+            LOG_ERROR(Service_NS, "Failed to create sharedfonts path \"{}\"!", filepath);
+            return;
+        }
+        FileUtil::IOFile file(filepath, "rb");
+
+        shared_font = std::make_shared<std::vector<u8>>(
+            SHARED_FONT_MEM_SIZE); // Shared memory needs to always be allocated and a fixed size
+        if (file.IsOpen()) {
+            // Read shared font data
+            ASSERT(file.GetSize() == SHARED_FONT_MEM_SIZE);
+            file.ReadBytes(shared_font->data(), shared_font->size());
+            BuildSharedFontsRawRegions(*shared_font);
+        } else {
+            LOG_WARNING(Service_NS, "Unable to load shared font: {}", filepath);
+        }
     }
 }
 
 void PL_U::RequestLoad(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const u32 shared_font_type{rp.Pop<u32>()};
-
+    // Games don't call this so all fonts should be loaded
     LOG_DEBUG(Service_NS, "called, shared_font_type={}", shared_font_type);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
@@ -82,7 +201,7 @@ void PL_U::GetSize(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_NS, "called, font_id={}", font_id);
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(SHARED_FONT_REGIONS[font_id].size);
+    rb.Push<u32>(GetSharedFontRegion(font_id).size);
 }
 
 void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
@@ -92,14 +211,10 @@ void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_NS, "called, font_id={}", font_id);
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(SHARED_FONT_REGIONS[font_id].offset);
+    rb.Push<u32>(GetSharedFontRegion(font_id).offset);
 }
 
 void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
-    // TODO(bunnei): This is a less-than-ideal solution to load a RAM dump of the Switch shared
-    // font data. This (likely) relies on exact address, size, and offsets from the original
-    // dump. In the future, we need to replace this with a more robust solution.
-
     // Map backing memory for the font data
     Core::CurrentProcess()->vm_manager.MapMemoryBlock(
         SHARED_FONT_MEM_VADDR, shared_font, 0, SHARED_FONT_MEM_SIZE, Kernel::MemoryState::Shared);
@@ -128,8 +243,9 @@ void PL_U::GetSharedFontInOrderOfPriority(Kernel::HLERequestContext& ctx) {
     // TODO(ogniK): Have actual priority order
     for (size_t i = 0; i < SHARED_FONT_REGIONS.size(); i++) {
         font_codes.push_back(static_cast<u32>(i));
-        font_offsets.push_back(SHARED_FONT_REGIONS[i].offset);
-        font_sizes.push_back(SHARED_FONT_REGIONS[i].size);
+        auto region = GetSharedFontRegion(i);
+        font_offsets.push_back(region.offset);
+        font_sizes.push_back(region.size);
     }
 
     ctx.WriteBuffer(font_codes, 0);

src/core/loader/deconstructed_rom_directory.cpp

@@ -8,6 +8,7 @@
 #include "common/logging/log.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
+#include "core/file_sys/romfs_factory.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"

src/core/loader/nca.cpp

@@ -7,6 +7,7 @@
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/content_archive.h"
+#include "core/file_sys/romfs_factory.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/deconstructed_rom_directory.h"

src/core/perf_stats.cpp

@@ -76,22 +76,31 @@ double PerfStats::GetLastFrameTimeScale() {
 void FrameLimiter::DoFrameLimiting(microseconds current_system_time_us) {
     // Max lag caused by slow frames. Can be adjusted to compensate for too many slow frames. Higher
     // values increase the time needed to recover and limit framerate again after spikes.
-    constexpr microseconds MAX_LAG_TIME_US = 25us;
+    constexpr microseconds MAX_LAG_TIME_US = 25000us;
 
-    if (!Settings::values.toggle_framelimit) {
+    if (!Settings::values.use_frame_limit) {
         return;
     }
 
     auto now = Clock::now();
 
-    frame_limiting_delta_err += current_system_time_us - previous_system_time_us;
+    const double sleep_scale = Settings::values.frame_limit / 100.0;
+
+    // Max lag caused by slow frames. Shouldn't be more than the length of a frame at the current
+    // speed percent or it will clamp too much and prevent this from properly limiting to that
+    // percent. High values means it'll take longer after a slow frame to recover and start
+    // limiting
+    const microseconds max_lag_time_us = duration_cast<microseconds>(
+        std::chrono::duration<double, std::chrono::microseconds::period>(25ms / sleep_scale));
+    frame_limiting_delta_err += duration_cast<microseconds>(
+        std::chrono::duration<double, std::chrono::microseconds::period>(
+            (current_system_time_us - previous_system_time_us) / sleep_scale));
     frame_limiting_delta_err -= duration_cast<microseconds>(now - previous_walltime);
     frame_limiting_delta_err =
-        std::clamp(frame_limiting_delta_err, -MAX_LAG_TIME_US, MAX_LAG_TIME_US);
+        std::clamp(frame_limiting_delta_err, -max_lag_time_us, max_lag_time_us);
 
     if (frame_limiting_delta_err > microseconds::zero()) {
         std::this_thread::sleep_for(frame_limiting_delta_err);
-
         auto now_after_sleep = Clock::now();
         frame_limiting_delta_err -= duration_cast<microseconds>(now_after_sleep - now);
         now = now_after_sleep;

src/core/settings.h

@@ -130,7 +130,8 @@ struct Values {
 
     // Renderer
     float resolution_factor;
-    bool toggle_framelimit;
+    bool use_frame_limit;
+    u16 frame_limit;
     bool use_accurate_framebuffers;
 
     float bg_red;

src/core/telemetry_session.cpp

@@ -106,8 +106,9 @@ TelemetrySession::TelemetrySession() {
              Settings::values.use_multi_core);
     AddField(Telemetry::FieldType::UserConfig, "Renderer_ResolutionFactor",
              Settings::values.resolution_factor);
-    AddField(Telemetry::FieldType::UserConfig, "Renderer_ToggleFramelimit",
-             Settings::values.toggle_framelimit);
+    AddField(Telemetry::FieldType::UserConfig, "Renderer_UseFrameLimit",
+             Settings::values.use_frame_limit);
+    AddField(Telemetry::FieldType::UserConfig, "Renderer_FrameLimit", Settings::values.frame_limit);
     AddField(Telemetry::FieldType::UserConfig, "Renderer_UseAccurateFramebuffers",
              Settings::values.use_accurate_framebuffers);
     AddField(Telemetry::FieldType::UserConfig, "System_UseDockedMode",

src/video_core/engines/maxwell_3d.h

@@ -311,6 +311,36 @@ public:
             AlwaysOld = 8,
         };
 
+        enum class LogicOperation : u32 {
+            Clear = 0x1500,
+            And = 0x1501,
+            AndReverse = 0x1502,
+            Copy = 0x1503,
+            AndInverted = 0x1504,
+            NoOp = 0x1505,
+            Xor = 0x1506,
+            Or = 0x1507,
+            Nor = 0x1508,
+            Equiv = 0x1509,
+            Invert = 0x150A,
+            OrReverse = 0x150B,
+            CopyInverted = 0x150C,
+            OrInverted = 0x150D,
+            Nand = 0x150E,
+            Set = 0x150F,
+        };
+
+        enum class StencilOp : u32 {
+            Keep = 1,
+            Zero = 2,
+            Replace = 3,
+            Incr = 4,
+            Decr = 5,
+            Invert = 6,
+            IncrWrap = 7,
+            DecrWrap = 8,
+        };
+
         struct Cull {
             enum class FrontFace : u32 {
                 ClockWise = 0x0900,
@@ -489,8 +519,16 @@ public:
 
                 float clear_color[4];
                 float clear_depth;
+                INSERT_PADDING_WORDS(0x3);
+                s32 clear_stencil;
 
-                INSERT_PADDING_WORDS(0x93);
+                INSERT_PADDING_WORDS(0x6C);
+
+                s32 stencil_back_func_ref;
+                u32 stencil_back_mask;
+                u32 stencil_back_func_mask;
+
+                INSERT_PADDING_WORDS(0x20);
 
                 struct {
                     u32 address_high;
@@ -554,16 +592,14 @@ public:
                     u32 enable[NumRenderTargets];
                 } blend;
 
-                struct {
-                    u32 enable;
-                    u32 front_op_fail;
-                    u32 front_op_zfail;
-                    u32 front_op_zpass;
-                    u32 front_func_func;
-                    u32 front_func_ref;
-                    u32 front_func_mask;
-                    u32 front_mask;
-                } stencil;
+                u32 stencil_enable;
+                StencilOp stencil_front_op_fail;
+                StencilOp stencil_front_op_zfail;
+                StencilOp stencil_front_op_zpass;
+                ComparisonOp stencil_front_func_func;
+                s32 stencil_front_func_ref;
+                u32 stencil_front_func_mask;
+                u32 stencil_front_mask;
 
                 INSERT_PADDING_WORDS(0x3);
 
@@ -607,13 +643,11 @@ public:
 
                 INSERT_PADDING_WORDS(0x5);
 
-                struct {
-                    u32 enable;
-                    u32 back_op_fail;
-                    u32 back_op_zfail;
-                    u32 back_op_zpass;
-                    u32 back_func_func;
-                } stencil_two_side;
+                u32 stencil_two_side_enable;
+                StencilOp stencil_back_op_fail;
+                StencilOp stencil_back_op_zfail;
+                StencilOp stencil_back_op_zpass;
+                ComparisonOp stencil_back_func_func;
 
                 INSERT_PADDING_WORDS(0x17);
 
@@ -695,7 +729,14 @@ public:
 
                 Cull cull;
 
-                INSERT_PADDING_WORDS(0x2B);
+                INSERT_PADDING_WORDS(0x28);
+
+                struct {
+                    u32 enable;
+                    LogicOperation operation;
+                } logic_op;
+
+                INSERT_PADDING_WORDS(0x1);
 
                 union {
                     u32 raw;
@@ -918,6 +959,10 @@ ASSERT_REG_POSITION(viewport, 0x300);
 ASSERT_REG_POSITION(vertex_buffer, 0x35D);
 ASSERT_REG_POSITION(clear_color[0], 0x360);
 ASSERT_REG_POSITION(clear_depth, 0x364);
+ASSERT_REG_POSITION(clear_stencil, 0x368);
+ASSERT_REG_POSITION(stencil_back_func_ref, 0x3D5);
+ASSERT_REG_POSITION(stencil_back_mask, 0x3D6);
+ASSERT_REG_POSITION(stencil_back_func_mask, 0x3D7);
 ASSERT_REG_POSITION(zeta, 0x3F8);
 ASSERT_REG_POSITION(vertex_attrib_format[0], 0x458);
 ASSERT_REG_POSITION(rt_control, 0x487);
@@ -929,19 +974,31 @@ ASSERT_REG_POSITION(depth_write_enabled, 0x4BA);
 ASSERT_REG_POSITION(d3d_cull_mode, 0x4C2);
 ASSERT_REG_POSITION(depth_test_func, 0x4C3);
 ASSERT_REG_POSITION(blend, 0x4CF);
-ASSERT_REG_POSITION(stencil, 0x4E0);
+ASSERT_REG_POSITION(stencil_enable, 0x4E0);
+ASSERT_REG_POSITION(stencil_front_op_fail, 0x4E1);
+ASSERT_REG_POSITION(stencil_front_op_zfail, 0x4E2);
+ASSERT_REG_POSITION(stencil_front_op_zpass, 0x4E3);
+ASSERT_REG_POSITION(stencil_front_func_func, 0x4E4);
+ASSERT_REG_POSITION(stencil_front_func_ref, 0x4E5);
+ASSERT_REG_POSITION(stencil_front_func_mask, 0x4E6);
+ASSERT_REG_POSITION(stencil_front_mask, 0x4E7);
 ASSERT_REG_POSITION(screen_y_control, 0x4EB);
 ASSERT_REG_POSITION(vb_element_base, 0x50D);
 ASSERT_REG_POSITION(zeta_enable, 0x54E);
 ASSERT_REG_POSITION(tsc, 0x557);
 ASSERT_REG_POSITION(tic, 0x55D);
-ASSERT_REG_POSITION(stencil_two_side, 0x565);
+ASSERT_REG_POSITION(stencil_two_side_enable, 0x565);
+ASSERT_REG_POSITION(stencil_back_op_fail, 0x566);
+ASSERT_REG_POSITION(stencil_back_op_zfail, 0x567);
+ASSERT_REG_POSITION(stencil_back_op_zpass, 0x568);
+ASSERT_REG_POSITION(stencil_back_func_func, 0x569);
 ASSERT_REG_POSITION(point_coord_replace, 0x581);
 ASSERT_REG_POSITION(code_address, 0x582);
 ASSERT_REG_POSITION(draw, 0x585);
 ASSERT_REG_POSITION(index_array, 0x5F2);
 ASSERT_REG_POSITION(instanced_arrays, 0x620);
 ASSERT_REG_POSITION(cull, 0x646);
+ASSERT_REG_POSITION(logic_op, 0x671);
 ASSERT_REG_POSITION(clear_buffers, 0x674);
 ASSERT_REG_POSITION(query, 0x6C0);
 ASSERT_REG_POSITION(vertex_array[0], 0x700);

src/video_core/engines/shader_bytecode.h

@@ -280,6 +280,19 @@ union Instruction {
             BitField<56, 1, u64> invert_b;
         } lop32i;
 
+        union {
+            BitField<28, 8, u64> imm_lut28;
+            BitField<48, 8, u64> imm_lut48;
+
+            u32 GetImmLut28() const {
+                return static_cast<u32>(imm_lut28);
+            }
+
+            u32 GetImmLut48() const {
+                return static_cast<u32>(imm_lut48);
+            }
+        } lop3;
+
         u32 GetImm20_19() const {
             u32 imm{static_cast<u32>(imm20_19)};
             imm <<= 12;
@@ -518,7 +531,7 @@ union Instruction {
                 return TextureType::Texture1D;
             }
             if (texture_info == 2 || texture_info == 8 || texture_info == 12 ||
-                texture_info >= 4 && texture_info <= 6) {
+                (texture_info >= 4 && texture_info <= 6)) {
                 return TextureType::Texture2D;
             }
             if (texture_info == 7) {
@@ -650,6 +663,9 @@ public:
         LOP_R,
         LOP_IMM,
         LOP32I,
+        LOP3_C,
+        LOP3_R,
+        LOP3_IMM,
         MOV_C,
         MOV_R,
         MOV_IMM,
@@ -872,6 +888,9 @@ private:
             INST("0101110001000---", Id::LOP_R, Type::ArithmeticInteger, "LOP_R"),
             INST("0011100001000---", Id::LOP_IMM, Type::ArithmeticInteger, "LOP_IMM"),
             INST("000001----------", Id::LOP32I, Type::ArithmeticIntegerImmediate, "LOP32I"),
+            INST("0000001---------", Id::LOP3_C, Type::ArithmeticInteger, "LOP3_C"),
+            INST("0101101111100---", Id::LOP3_R, Type::ArithmeticInteger, "LOP3_R"),
+            INST("0011110---------", Id::LOP3_IMM, Type::ArithmeticInteger, "LOP3_IMM"),
             INST("0100110001001---", Id::SHL_C, Type::Shift, "SHL_C"),
             INST("0101110001001---", Id::SHL_R, Type::Shift, "SHL_R"),
             INST("0011100-01001---", Id::SHL_IMM, Type::Shift, "SHL_IMM"),

src/video_core/rasterizer_interface.h

@@ -8,8 +8,6 @@
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
 
-struct ScreenInfo;
-
 namespace VideoCore {
 
 class RasterizerInterface {
@@ -55,7 +53,7 @@ public:
 
     /// Attempt to use a faster method to display the framebuffer to screen
     virtual bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr,
-                                   u32 pixel_stride, ScreenInfo& screen_info) {
+                                   u32 pixel_stride) {
         return false;
     }
 

src/video_core/renderer_base.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <memory>
 #include "core/frontend/emu_window.h"
 #include "core/settings.h"
 #include "video_core/renderer_base.h"
@@ -17,16 +16,9 @@ RendererBase::RendererBase(Core::Frontend::EmuWindow& window) : render_window{wi
 RendererBase::~RendererBase() = default;
 
 void RendererBase::RefreshBaseSettings() {
-    RefreshRasterizerSetting();
     UpdateCurrentFramebufferLayout();
 
-    renderer_settings.use_framelimiter = Settings::values.toggle_framelimit;
-}
-
-void RendererBase::RefreshRasterizerSetting() {
-    if (rasterizer == nullptr) {
-        rasterizer = std::make_unique<RasterizerOpenGL>(render_window);
-    }
+    renderer_settings.use_framelimiter = Settings::values.use_frame_limit;
 }
 
 void RendererBase::UpdateCurrentFramebufferLayout() {

src/video_core/renderer_base.h

@@ -58,9 +58,6 @@ public:
     void RefreshBaseSettings();
 
 protected:
-    /// Refreshes settings specific to the rasterizer.
-    void RefreshRasterizerSetting();
-
     Core::Frontend::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

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -14,6 +14,7 @@
 #include "common/logging/log.h"
 #include "common/math_util.h"
 #include "common/microprofile.h"
+#include "common/scope_exit.h"
 #include "core/core.h"
 #include "core/frontend/emu_window.h"
 #include "core/hle/kernel/process.h"
@@ -25,6 +26,8 @@
 #include "video_core/renderer_opengl/renderer_opengl.h"
 #include "video_core/video_core.h"
 
+namespace OpenGL {
+
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 using PixelFormat = SurfaceParams::PixelFormat;
 using SurfaceType = SurfaceParams::SurfaceType;
@@ -36,8 +39,8 @@ 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(Core::Frontend::EmuWindow& window, ScreenInfo& info)
+    : emu_window{window}, screen_info{info}, stream_buffer(GL_ARRAY_BUFFER, STREAM_BUFFER_SIZE) {
     // Create sampler objects
     for (size_t i = 0; i < texture_samplers.size(); ++i) {
         texture_samplers[i].Create();
@@ -179,7 +182,7 @@ static GLShader::ProgramCode GetShaderProgramCode(Maxwell::ShaderProgram program
     auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
 
     // Fetch program code from memory
-    GLShader::ProgramCode program_code;
+    GLShader::ProgramCode program_code(GLShader::MAX_PROGRAM_CODE_LENGTH);
     auto& shader_config = gpu.regs.shader_config[static_cast<size_t>(program)];
     const u64 gpu_address{gpu.regs.code_address.CodeAddress() + shader_config.offset};
     const boost::optional<VAddr> cpu_address{gpu.memory_manager.GpuToCpuAddress(gpu_address)};
@@ -304,7 +307,8 @@ bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
 }
 
 std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb,
-                                                                    bool using_depth_fb) {
+                                                                    bool using_depth_fb,
+                                                                    bool preserve_contents) {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 
     if (regs.rt[0].format == Tegra::RenderTargetFormat::NONE) {
@@ -312,22 +316,20 @@ std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_c
         using_color_fb = false;
     }
 
-    // TODO(bunnei): Implement this
-    const bool has_stencil = false;
-
+    const bool has_stencil = regs.stencil_enable;
     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;
 
     const bool write_depth_fb =
         (state.depth.test_enabled && state.depth.write_mask == GL_TRUE) ||
-        (has_stencil && state.stencil.test_enabled && state.stencil.write_mask != 0);
+        (has_stencil && (state.stencil.front.write_mask || state.stencil.back.write_mask));
 
     Surface color_surface;
     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, preserve_contents);
 
     const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[0].GetRect()};
     const MathUtil::Rectangle<u32> draw_rect{
@@ -361,41 +363,70 @@ std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_c
 }
 
 void RasterizerOpenGL::Clear() {
-    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+    const auto prev_state{state};
+    SCOPE_EXIT({ prev_state.Apply(); });
 
+    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
     bool use_color_fb = false;
     bool use_depth_fb = false;
 
-    GLbitfield clear_mask = 0;
-    if (regs.clear_buffers.R && regs.clear_buffers.G && regs.clear_buffers.B &&
+    OpenGLState clear_state;
+    clear_state.draw.draw_framebuffer = state.draw.draw_framebuffer;
+    clear_state.color_mask.red_enabled = regs.clear_buffers.R ? GL_TRUE : GL_FALSE;
+    clear_state.color_mask.green_enabled = regs.clear_buffers.G ? GL_TRUE : GL_FALSE;
+    clear_state.color_mask.blue_enabled = regs.clear_buffers.B ? GL_TRUE : GL_FALSE;
+    clear_state.color_mask.alpha_enabled = regs.clear_buffers.A ? GL_TRUE : GL_FALSE;
+
+    GLbitfield clear_mask{};
+    if (regs.clear_buffers.R || regs.clear_buffers.G || regs.clear_buffers.B ||
         regs.clear_buffers.A) {
-        clear_mask |= GL_COLOR_BUFFER_BIT;
-        use_color_fb = true;
+        if (regs.clear_buffers.RT == 0) {
+            // We only support clearing the first color attachment for now
+            clear_mask |= GL_COLOR_BUFFER_BIT;
+            use_color_fb = true;
+        } else {
+            // TODO(subv): Add support for the other color attachments
+            LOG_CRITICAL(HW_GPU, "Clear unimplemented for RT {}", regs.clear_buffers.RT);
+        }
     }
     if (regs.clear_buffers.Z) {
+        ASSERT_MSG(regs.zeta_enable != 0, "Tried to clear Z but buffer is not enabled!");
+        use_depth_fb = true;
         clear_mask |= GL_DEPTH_BUFFER_BIT;
-        use_depth_fb = regs.zeta_enable != 0;
 
         // Always enable the depth write when clearing the depth buffer. The depth write mask is
         // ignored when clearing the buffer in the Switch, but OpenGL obeys it so we set it to true.
-        state.depth.test_enabled = true;
-        state.depth.write_mask = GL_TRUE;
-        state.depth.test_func = GL_ALWAYS;
-        state.Apply();
+        clear_state.depth.test_enabled = true;
+        clear_state.depth.test_func = GL_ALWAYS;
+    }
+    if (regs.clear_buffers.S) {
+        ASSERT_MSG(regs.zeta_enable != 0, "Tried to clear stencil but buffer is not enabled!");
+        use_depth_fb = true;
+        clear_mask |= GL_STENCIL_BUFFER_BIT;
+        clear_state.stencil.test_enabled = true;
     }
 
-    if (clear_mask == 0)
+    if (!use_color_fb && !use_depth_fb) {
+        // No color surface nor depth/stencil surface are enabled
         return;
+    }
+
+    if (clear_mask == 0) {
+        // No clear mask is enabled
+        return;
+    }
 
     ScopeAcquireGLContext acquire_context{emu_window};
 
     auto [dirty_color_surface, dirty_depth_surface] =
-        ConfigureFramebuffers(use_color_fb, use_depth_fb);
+        ConfigureFramebuffers(use_color_fb, use_depth_fb, false);
+
+    clear_state.Apply();
 
-    // TODO(Subv): Support clearing only partial colors.
     glClearColor(regs.clear_color[0], regs.clear_color[1], regs.clear_color[2],
                  regs.clear_color[3]);
     glClearDepth(regs.clear_depth);
+    glClearStencil(regs.clear_stencil);
 
     glClear(clear_mask);
 
@@ -445,10 +476,12 @@ void RasterizerOpenGL::DrawArrays() {
     ScopeAcquireGLContext acquire_context{emu_window};
 
     auto [dirty_color_surface, dirty_depth_surface] =
-        ConfigureFramebuffers(true, regs.zeta.Address() != 0 && regs.zeta_enable != 0);
+        ConfigureFramebuffers(true, regs.zeta.Address() != 0 && regs.zeta_enable != 0, true);
 
     SyncDepthTestState();
+    SyncStencilTestState();
     SyncBlendState();
+    SyncLogicOpState();
     SyncCullMode();
 
     // TODO(bunnei): Sync framebuffer_scale uniform here
@@ -574,8 +607,7 @@ bool RasterizerOpenGL::AccelerateFill(const void* config) {
 }
 
 bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
-                                         VAddr framebuffer_addr, u32 pixel_stride,
-                                         ScreenInfo& screen_info) {
+                                         VAddr framebuffer_addr, u32 pixel_stride) {
     if (!framebuffer_addr) {
         return {};
     }
@@ -838,6 +870,34 @@ void RasterizerOpenGL::SyncDepthTestState() {
     state.depth.test_func = MaxwellToGL::ComparisonOp(regs.depth_test_func);
 }
 
+void RasterizerOpenGL::SyncStencilTestState() {
+    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+    state.stencil.test_enabled = regs.stencil_enable != 0;
+
+    if (!regs.stencil_enable) {
+        return;
+    }
+
+    // TODO(bunnei): Verify behavior when this is not set
+    ASSERT(regs.stencil_two_side_enable);
+
+    state.stencil.front.test_func = MaxwellToGL::ComparisonOp(regs.stencil_front_func_func);
+    state.stencil.front.test_ref = regs.stencil_front_func_ref;
+    state.stencil.front.test_mask = regs.stencil_front_func_mask;
+    state.stencil.front.action_stencil_fail = MaxwellToGL::StencilOp(regs.stencil_front_op_fail);
+    state.stencil.front.action_depth_fail = MaxwellToGL::StencilOp(regs.stencil_front_op_zfail);
+    state.stencil.front.action_depth_pass = MaxwellToGL::StencilOp(regs.stencil_front_op_zpass);
+    state.stencil.front.write_mask = regs.stencil_front_mask;
+
+    state.stencil.back.test_func = MaxwellToGL::ComparisonOp(regs.stencil_back_func_func);
+    state.stencil.back.test_ref = regs.stencil_back_func_ref;
+    state.stencil.back.test_mask = regs.stencil_back_func_mask;
+    state.stencil.back.action_stencil_fail = MaxwellToGL::StencilOp(regs.stencil_back_op_fail);
+    state.stencil.back.action_depth_fail = MaxwellToGL::StencilOp(regs.stencil_back_op_zfail);
+    state.stencil.back.action_depth_pass = MaxwellToGL::StencilOp(regs.stencil_back_op_zpass);
+    state.stencil.back.write_mask = regs.stencil_back_mask;
+}
+
 void RasterizerOpenGL::SyncBlendState() {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 
@@ -847,6 +907,9 @@ void RasterizerOpenGL::SyncBlendState() {
     if (!state.blend.enabled)
         return;
 
+    ASSERT_MSG(regs.logic_op.enable == 0,
+               "Blending and logic op can't be enabled at the same time.");
+
     ASSERT_MSG(regs.independent_blend_enable == 1, "Only independent blending is implemented");
     ASSERT_MSG(!regs.independent_blend[0].separate_alpha, "Unimplemented");
     state.blend.rgb_equation = MaxwellToGL::BlendEquation(regs.independent_blend[0].equation_rgb);
@@ -856,3 +919,19 @@ void RasterizerOpenGL::SyncBlendState() {
     state.blend.src_a_func = MaxwellToGL::BlendFunc(regs.independent_blend[0].factor_source_a);
     state.blend.dst_a_func = MaxwellToGL::BlendFunc(regs.independent_blend[0].factor_dest_a);
 }
+
+void RasterizerOpenGL::SyncLogicOpState() {
+    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+
+    // TODO(Subv): Support more than just render target 0.
+    state.logic_op.enabled = regs.logic_op.enable != 0;
+
+    if (!state.logic_op.enabled)
+        return;
+
+    ASSERT_MSG(regs.blend.enable == 0, "Blending and logic op can't be enabled at the same time.");
+
+    state.logic_op.operation = MaxwellToGL::LogicOp(regs.logic_op.operation);
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -22,15 +22,17 @@
 #include "video_core/renderer_opengl/gl_state.h"
 #include "video_core/renderer_opengl/gl_stream_buffer.h"
 
-struct ScreenInfo;
-
 namespace Core::Frontend {
 class EmuWindow;
 }
 
+namespace OpenGL {
+
+struct ScreenInfo;
+
 class RasterizerOpenGL : public VideoCore::RasterizerInterface {
 public:
-    explicit RasterizerOpenGL(Core::Frontend::EmuWindow& renderer);
+    explicit RasterizerOpenGL(Core::Frontend::EmuWindow& renderer, ScreenInfo& info);
     ~RasterizerOpenGL() override;
 
     void DrawArrays() override;
@@ -43,8 +45,8 @@ public:
     bool AccelerateDisplayTransfer(const void* config) override;
     bool AccelerateTextureCopy(const void* config) override;
     bool AccelerateFill(const void* config) override;
-    bool AccelerateDisplay(const Tegra::FramebufferConfig& framebuffer, VAddr framebuffer_addr,
-                           u32 pixel_stride, ScreenInfo& screen_info) override;
+    bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr,
+                           u32 pixel_stride) override;
     bool AccelerateDrawBatch(bool is_indexed) override;
 
     /// OpenGL shader generated for a given Maxwell register state
@@ -87,7 +89,8 @@ private:
 
     /// Configures the color and depth framebuffer states and returns the dirty <Color, Depth>
     /// surfaces if writing was enabled.
-    std::pair<Surface, Surface> ConfigureFramebuffers(bool using_color_fb, bool using_depth_fb);
+    std::pair<Surface, Surface> ConfigureFramebuffers(bool using_color_fb, bool using_depth_fb,
+                                                      bool preserve_contents);
 
     /// Binds the framebuffer color and depth surface
     void BindFramebufferSurfaces(const Surface& color_surface, const Surface& depth_surface,
@@ -138,9 +141,15 @@ private:
     /// Syncs the depth test state to match the guest state
     void SyncDepthTestState();
 
+    /// Syncs the stencil test state to match the guest state
+    void SyncStencilTestState();
+
     /// Syncs the blend state to match the guest state
     void SyncBlendState();
 
+    /// Syncs the LogicOp state to match the guest state
+    void SyncLogicOpState();
+
     bool has_ARB_direct_state_access = false;
     bool has_ARB_separate_shader_objects = false;
     bool has_ARB_vertex_attrib_binding = false;
@@ -151,6 +160,8 @@ private:
 
     Core::Frontend::EmuWindow& emu_window;
 
+    ScreenInfo& screen_info;
+
     std::unique_ptr<GLShader::ProgramManager> shader_program_manager;
     OGLVertexArray sw_vao;
     OGLVertexArray hw_vao;
@@ -178,3 +189,5 @@ private:
     enum class AccelDraw { Disabled, Arrays, Indexed };
     AccelDraw accelerate_draw = AccelDraw::Disabled;
 };
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -19,6 +19,8 @@
 #include "video_core/textures/decoders.h"
 #include "video_core/utils.h"
 
+namespace OpenGL {
+
 using SurfaceType = SurfaceParams::SurfaceType;
 using PixelFormat = SurfaceParams::PixelFormat;
 using ComponentType = SurfaceParams::ComponentType;
@@ -686,7 +688,8 @@ Surface RasterizerCacheOpenGL::GetTextureSurface(const Tegra::Texture::FullTextu
 }
 
 SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool using_color_fb,
-                                                                       bool using_depth_fb) {
+                                                                       bool using_depth_fb,
+                                                                       bool preserve_contents) {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 
     // TODO(bunnei): This is hard corded to use just the first render buffer
@@ -708,7 +711,7 @@ SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool usin
     MathUtil::Rectangle<u32> color_rect{};
     Surface color_surface;
     if (using_color_fb) {
-        color_surface = GetSurface(color_params);
+        color_surface = GetSurface(color_params, preserve_contents);
         if (color_surface) {
             color_rect = color_surface->GetSurfaceParams().GetRect();
         }
@@ -717,7 +720,7 @@ SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool usin
     MathUtil::Rectangle<u32> depth_rect{};
     Surface depth_surface;
     if (using_depth_fb) {
-        depth_surface = GetSurface(depth_params);
+        depth_surface = GetSurface(depth_params, preserve_contents);
         if (depth_surface) {
             depth_rect = depth_surface->GetSurfaceParams().GetRect();
         }
@@ -752,7 +755,7 @@ void RasterizerCacheOpenGL::FlushSurface(const Surface& surface) {
     surface->FlushGLBuffer();
 }
 
-Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params) {
+Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool preserve_contents) {
     if (params.addr == 0 || params.height * params.width == 0) {
         return {};
     }
@@ -774,9 +777,13 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params) {
         } else if (surface->GetSurfaceParams().IsCompatibleSurface(params)) {
             // Use the cached surface as-is
             return surface;
-        } else {
-            // If surface parameters changed, recreate the surface from the old one
+        } else if (preserve_contents) {
+            // If surface parameters changed and we care about keeping the previous data, recreate
+            // the surface from the old one
             return RecreateSurface(surface, params);
+        } else {
+            // Delete the old surface before creating a new one to prevent collisions.
+            UnregisterSurface(surface);
         }
     }
 
@@ -793,12 +800,58 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& surface,
     // Verify surface is compatible for blitting
     const auto& params{surface->GetSurfaceParams()};
     ASSERT(params.type == new_params.type);
+    ASSERT_MSG(params.GetCompressionFactor(params.pixel_format) == 1,
+               "Compressed texture reinterpretation is not supported");
 
     // Create a new surface with the new parameters, and blit the previous surface to it
     Surface new_surface{std::make_shared<CachedSurface>(new_params)};
-    BlitTextures(surface->Texture().handle, params.GetRect(), new_surface->Texture().handle,
-                 new_surface->GetSurfaceParams().GetRect(), params.type, read_framebuffer.handle,
-                 draw_framebuffer.handle);
+
+    auto source_format = GetFormatTuple(params.pixel_format, params.component_type);
+    auto dest_format = GetFormatTuple(new_params.pixel_format, new_params.component_type);
+
+    size_t buffer_size = std::max(params.SizeInBytes(), new_params.SizeInBytes());
+
+    // Use a Pixel Buffer Object to download the previous texture and then upload it to the new one
+    // using the new format.
+    OGLBuffer pbo;
+    pbo.Create();
+
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo.handle);
+    glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW_ARB);
+    glGetTextureImage(surface->Texture().handle, 0, source_format.format, source_format.type,
+                      params.SizeInBytes(), nullptr);
+
+    // If the new texture is bigger than the previous one, we need to fill in the rest with data
+    // from the CPU.
+    if (params.SizeInBytes() < new_params.SizeInBytes()) {
+        // Upload the rest of the memory.
+        if (new_params.is_tiled) {
+            // TODO(Subv): We might have to de-tile the subtexture and re-tile it with the rest of
+            // the data in this case. Games like Super Mario Odyssey seem to hit this case when
+            // drawing, it re-uses the memory of a previous texture as a bigger framebuffer but it
+            // doesn't clear it beforehand, the texture is already full of zeros.
+            LOG_CRITICAL(HW_GPU, "Trying to upload extra texture data from the CPU during "
+                                 "reinterpretation but the texture is tiled.");
+        }
+        size_t remaining_size = new_params.SizeInBytes() - params.SizeInBytes();
+        auto address = Core::System::GetInstance().GPU().memory_manager->GpuToCpuAddress(
+            new_params.addr + params.SizeInBytes());
+        std::vector<u8> data(remaining_size);
+        Memory::ReadBlock(*address, data.data(), data.size());
+        glBufferSubData(GL_PIXEL_PACK_BUFFER, params.SizeInBytes(), remaining_size, data.data());
+    }
+
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+
+    const auto& dest_rect{new_params.GetRect()};
+
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo.handle);
+    glTextureSubImage2D(
+        new_surface->Texture().handle, 0, 0, 0, static_cast<GLsizei>(dest_rect.GetWidth()),
+        static_cast<GLsizei>(dest_rect.GetHeight()), dest_format.format, dest_format.type, nullptr);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+
+    pbo.Release();
 
     // Update cache accordingly
     UnregisterSurface(surface);
@@ -916,3 +969,5 @@ void RasterizerCacheOpenGL::UpdatePagesCachedCount(Tegra::GPUVAddr addr, u64 siz
     if (delta < 0)
         cached_pages.add({pages_interval, delta});
 }
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -16,6 +16,8 @@
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/textures/texture.h"
 
+namespace OpenGL {
+
 class CachedSurface;
 using Surface = std::shared_ptr<CachedSurface>;
 using SurfaceSurfaceRect_Tuple = std::tuple<Surface, Surface, MathUtil::Rectangle<u32>>;
@@ -722,7 +724,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,
+                                                    bool preserve_contents);
 
     /// Flushes the surface to Switch memory
     void FlushSurface(const Surface& surface);
@@ -738,7 +741,7 @@ public:
 
 private:
     void LoadSurface(const Surface& surface);
-    Surface GetSurface(const SurfaceParams& params);
+    Surface GetSurface(const SurfaceParams& params, bool preserve_contents = true);
 
     /// Recreates a surface with new parameters
     Surface RecreateSurface(const Surface& surface, const SurfaceParams& new_params);
@@ -758,3 +761,5 @@ private:
     OGLFramebuffer read_framebuffer;
     OGLFramebuffer draw_framebuffer;
 };
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_resource_manager.h

@@ -10,6 +10,8 @@
 #include "video_core/renderer_opengl/gl_shader_util.h"
 #include "video_core/renderer_opengl/gl_state.h"
 
+namespace OpenGL {
+
 class OGLTexture : private NonCopyable {
 public:
     OGLTexture() = default;
@@ -331,3 +333,5 @@ public:
 
     GLuint handle = 0;
 };
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -15,7 +15,7 @@
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_decompiler.h"
 
-namespace GLShader::Decompiler {
+namespace OpenGL::GLShader::Decompiler {
 
 using Tegra::Shader::Attribute;
 using Tegra::Shader::Instruction;
@@ -440,12 +440,13 @@ public:
         }
         declarations.AddNewLine();
 
-        const auto& samplers = GetSamplers();
-        for (const auto& sampler : samplers) {
-            declarations.AddLine("uniform " + sampler.GetTypeString() + ' ' + sampler.GetName() +
-                                 ';');
+        // Append the sampler2D array for the used textures.
+        size_t num_samplers = GetSamplers().size();
+        if (num_samplers > 0) {
+            declarations.AddLine("uniform sampler2D " + SamplerEntry::GetArrayName(stage) + '[' +
+                                 std::to_string(num_samplers) + "];");
+            declarations.AddNewLine();
         }
-        declarations.AddNewLine();
     }
 
     /// Returns a list of constant buffer declarations
@@ -457,14 +458,13 @@ public:
     }
 
     /// Returns a list of samplers used in the shader
-    const std::vector<SamplerEntry>& GetSamplers() const {
+    std::vector<SamplerEntry> GetSamplers() const {
         return used_samplers;
     }
 
     /// Returns the GLSL sampler used for the input shader sampler, and creates a new one if
     /// necessary.
-    std::string AccessSampler(const Sampler& sampler, Tegra::Shader::TextureType type,
-                              bool is_array) {
+    std::string AccessSampler(const Sampler& sampler) {
         size_t offset = static_cast<size_t>(sampler.index.Value());
 
         // If this sampler has already been used, return the existing mapping.
@@ -473,13 +473,12 @@ public:
                          [&](const SamplerEntry& entry) { return entry.GetOffset() == offset; });
 
         if (itr != used_samplers.end()) {
-            ASSERT(itr->GetType() == type && itr->IsArray() == is_array);
             return itr->GetName();
         }
 
         // Otherwise create a new mapping for this sampler
         size_t next_index = used_samplers.size();
-        SamplerEntry entry{stage, offset, next_index, type, is_array};
+        SamplerEntry entry{stage, offset, next_index};
         used_samplers.emplace_back(entry);
         return entry.GetName();
     }
@@ -657,8 +656,8 @@ private:
     }
 
     /// Generates code representing a texture sampler.
-    std::string GetSampler(const Sampler& sampler, Tegra::Shader::TextureType type, bool is_array) {
-        return regs.AccessSampler(sampler, type, is_array);
+    std::string GetSampler(const Sampler& sampler) {
+        return regs.AccessSampler(sampler);
     }
 
     /**
@@ -850,6 +849,33 @@ private:
         }
     }
 
+    void WriteLop3Instruction(Register dest, const std::string& op_a, const std::string& op_b,
+                              const std::string& op_c, const std::string& imm_lut) {
+        if (dest == Tegra::Shader::Register::ZeroIndex) {
+            return;
+        }
+
+        static constexpr std::array<const char*, 32> shift_amounts = {
+            "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",  "8",  "9",  "10",
+            "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21",
+            "22", "23", "24", "25", "26", "27", "28", "29", "30", "31"};
+
+        std::string result;
+        result += '(';
+
+        for (size_t i = 0; i < shift_amounts.size(); ++i) {
+            if (i)
+                result += '|';
+            result += "(((" + imm_lut + " >> (((" + op_c + " >> " + shift_amounts[i] +
+                      ") & 1) | ((" + op_b + " >> " + shift_amounts[i] + ") & 1) << 1 | ((" + op_a +
+                      " >> " + shift_amounts[i] + ") & 1) << 2)) & 1) << " + shift_amounts[i] + ")";
+        }
+
+        result += ')';
+
+        regs.SetRegisterToInteger(dest, true, 0, result, 1, 1);
+    }
+
     void WriteTexsInstruction(const Instruction& instr, const std::string& coord,
                               const std::string& texture) {
         // Add an extra scope and declare the texture coords inside to prevent
@@ -918,7 +944,6 @@ private:
         FragmentHeader header;
         std::memcpy(&header, program_code.data(), PROGRAM_HEADER_SIZE);
 
-        ASSERT_MSG(header.writes_depth == 0, "Depth write is unimplemented");
         ASSERT_MSG(header.writes_samplemask == 0, "Samplemask write is unimplemented");
 
         // Write the color outputs using the data in the shader registers, disabled
@@ -935,6 +960,12 @@ private:
                 }
             }
         }
+
+        if (header.writes_depth) {
+            // The depth output is always 2 registers after the last color output, and current_reg
+            // already contains one past the last color register.
+            shader.AddLine("gl_FragDepth = " + regs.GetRegisterAsFloat(current_reg + 1) + ';');
+        }
     }
 
     /**
@@ -1293,6 +1324,20 @@ private:
                                     instr.alu.lop.pred_result_mode, instr.alu.lop.pred48);
                 break;
             }
+            case OpCode::Id::LOP3_C:
+            case OpCode::Id::LOP3_R:
+            case OpCode::Id::LOP3_IMM: {
+                std::string op_c = regs.GetRegisterAsInteger(instr.gpr39);
+                std::string lut;
+                if (opcode->GetId() == OpCode::Id::LOP3_R) {
+                    lut = '(' + std::to_string(instr.alu.lop3.GetImmLut28()) + ')';
+                } else {
+                    lut = '(' + std::to_string(instr.alu.lop3.GetImmLut48()) + ')';
+                }
+
+                WriteLop3Instruction(instr.gpr0, op_a, op_b, op_c, lut);
+                break;
+            }
             case OpCode::Id::IMNMX_C:
             case OpCode::Id::IMNMX_R:
             case OpCode::Id::IMNMX_IMM: {
@@ -1551,39 +1596,10 @@ private:
                 break;
             }
             case OpCode::Id::TEX: {
-                ASSERT_MSG(instr.tex.array == 0, "TEX arrays unimplemented");
-                std::string coord{};
-
-                switch (instr.tex.texture_type) {
-                case Tegra::Shader::TextureType::Texture2D: {
-                    std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                    std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    coord = "vec2 coords = vec2(" + x + ", " + y + ");";
-                    break;
-                }
-                case Tegra::Shader::TextureType::Texture3D: {
-                    std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                    std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    std::string z = regs.GetRegisterAsFloat(instr.gpr20);
-                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
-                    break;
-                }
-                case Tegra::Shader::TextureType::TextureCube: {
-                    std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                    std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    std::string z = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
-                    ASSERT(instr.gpr20.Value() == Register::ZeroIndex);
-                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
-                    break;
-                }
-                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
-                                 static_cast<u32>(instr.tex.texture_type.Value()));
-                    UNREACHABLE();
-                }
-
-                const std::string sampler =
-                    GetSampler(instr.sampler, instr.tex.texture_type, instr.tex.array);
+                const std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
+                const std::string op_b = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                const std::string sampler = GetSampler(instr.sampler);
+                const std::string coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
                 // Add an extra scope and declare the texture coords inside to prevent
                 // overwriting them in case they are used as outputs of the texs instruction.
                 shader.AddLine("{");
@@ -1605,72 +1621,20 @@ private:
                 break;
             }
             case OpCode::Id::TEXS: {
-                std::string coord{};
-
-                switch (instr.texs.GetTextureType()) {
-                case Tegra::Shader::TextureType::Texture2D: {
-                    if (instr.texs.IsArrayTexture()) {
-                        std::string index = regs.GetRegisterAsInteger(instr.gpr8);
-                        std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                        std::string y = regs.GetRegisterAsFloat(instr.gpr20);
-                        coord = "vec3 coords = vec3(" + x + ", " + y + ", " + index + ");";
-                    } else {
-                        std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                        std::string y = regs.GetRegisterAsFloat(instr.gpr20);
-                        coord = "vec2 coords = vec2(" + x + ", " + y + ");";
-                    }
-                    break;
-                }
-                case Tegra::Shader::TextureType::Texture3D: {
-                    std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                    std::string y = regs.GetRegisterAsFloat(instr.gpr20);
-                    std::string z = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
-                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
-                    break;
-                }
-                case Tegra::Shader::TextureType::TextureCube: {
-                    std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                    std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    std::string z = regs.GetRegisterAsFloat(instr.gpr20);
-                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
-                    break;
-                }
-                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
-                                 static_cast<u32>(instr.texs.GetTextureType()));
-                    UNREACHABLE();
-                }
-                const std::string sampler = GetSampler(instr.sampler, instr.texs.GetTextureType(),
-                                                       instr.texs.IsArrayTexture());
+                const std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
+                const std::string op_b = regs.GetRegisterAsFloat(instr.gpr20);
+                const std::string sampler = GetSampler(instr.sampler);
+                const std::string coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
 
                 const std::string texture = "texture(" + sampler + ", coords)";
                 WriteTexsInstruction(instr, coord, texture);
                 break;
             }
             case OpCode::Id::TLDS: {
-                ASSERT(instr.tlds.GetTextureType() == Tegra::Shader::TextureType::Texture2D);
-                ASSERT(instr.tlds.IsArrayTexture() == false);
-                std::string coord{};
-
-                switch (instr.tlds.GetTextureType()) {
-                case Tegra::Shader::TextureType::Texture2D: {
-                    if (instr.tlds.IsArrayTexture()) {
-                        LOG_CRITICAL(HW_GPU, "Unhandled 2d array texture");
-                        UNREACHABLE();
-                    } else {
-                        std::string x = regs.GetRegisterAsInteger(instr.gpr8);
-                        std::string y = regs.GetRegisterAsInteger(instr.gpr20);
-                        coord = "ivec2 coords = ivec2(" + x + ", " + y + ");";
-                    }
-                    break;
-                }
-                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
-                                 static_cast<u32>(instr.tlds.GetTextureType()));
-                    UNREACHABLE();
-                }
-                const std::string sampler = GetSampler(instr.sampler, instr.tlds.GetTextureType(),
-                                                       instr.tlds.IsArrayTexture());
+                const std::string op_a = regs.GetRegisterAsInteger(instr.gpr8);
+                const std::string op_b = regs.GetRegisterAsInteger(instr.gpr20);
+                const std::string sampler = GetSampler(instr.sampler);
+                const std::string coord = "ivec2 coords = ivec2(" + op_a + ", " + op_b + ");";
                 const std::string texture = "texelFetch(" + sampler + ", coords, 0)";
                 WriteTexsInstruction(instr, coord, texture);
                 break;
@@ -1693,8 +1657,7 @@ private:
                     UNREACHABLE();
                 }
 
-                const std::string sampler =
-                    GetSampler(instr.sampler, instr.tld4.texture_type, instr.tld4.array);
+                const std::string sampler = GetSampler(instr.sampler);
                 // Add an extra scope and declare the texture coords inside to prevent
                 // overwriting them in case they are used as outputs of the texs instruction.
                 shader.AddLine("{");
@@ -1720,8 +1683,7 @@ private:
                 const std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
                 const std::string op_b = regs.GetRegisterAsFloat(instr.gpr20);
                 // TODO(Subv): Figure out how the sampler type is encoded in the TLD4S instruction.
-                const std::string sampler =
-                    GetSampler(instr.sampler, Tegra::Shader::TextureType::Texture2D, false);
+                const std::string sampler = GetSampler(instr.sampler);
                 const std::string coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
                 const std::string texture = "textureGather(" + sampler + ", coords, " +
                                             std::to_string(instr.tld4s.component) + ')';
@@ -2255,4 +2217,4 @@ boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code,
     return boost::none;
 }
 
-} // namespace GLShader::Decompiler
+} // namespace OpenGL::GLShader::Decompiler

src/video_core/renderer_opengl/gl_shader_decompiler.h

@@ -12,7 +12,7 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
 
-namespace GLShader::Decompiler {
+namespace OpenGL::GLShader::Decompiler {
 
 using Tegra::Engines::Maxwell3D;
 
@@ -22,4 +22,4 @@ boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code,
                                                 Maxwell3D::Regs::ShaderStage stage,
                                                 const std::string& suffix);
 
-} // namespace GLShader::Decompiler
+} // namespace OpenGL::GLShader::Decompiler

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -7,7 +7,7 @@
 #include "video_core/renderer_opengl/gl_shader_decompiler.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
 
-namespace GLShader {
+namespace OpenGL::GLShader {
 
 using Tegra::Engines::Maxwell3D;
 
@@ -103,4 +103,4 @@ void main() {
     return {out, program.second};
 }
 
-} // namespace GLShader
+} // namespace OpenGL::GLShader

src/video_core/renderer_opengl/gl_shader_gen.h

@@ -9,15 +9,14 @@
 #include <type_traits>
 #include <utility>
 #include <vector>
+#include <boost/functional/hash.hpp>
 #include "common/common_types.h"
 #include "common/hash.h"
-#include "video_core/engines/shader_bytecode.h"
 
-namespace GLShader {
+namespace OpenGL::GLShader {
 
 constexpr size_t MAX_PROGRAM_CODE_LENGTH{0x1000};
-
-using ProgramCode = std::array<u64, MAX_PROGRAM_CODE_LENGTH>;
+using ProgramCode = std::vector<u64>;
 
 class ConstBufferEntry {
     using Maxwell = Tegra::Engines::Maxwell3D::Regs;
@@ -73,9 +72,8 @@ class SamplerEntry {
     using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 
 public:
-    SamplerEntry(Maxwell::ShaderStage stage, size_t offset, size_t index,
-                 Tegra::Shader::TextureType type, bool is_array)
-        : offset(offset), stage(stage), sampler_index(index), type(type), is_array(is_array) {}
+    SamplerEntry(Maxwell::ShaderStage stage, size_t offset, size_t index)
+        : offset(offset), stage(stage), sampler_index(index) {}
 
     size_t GetOffset() const {
         return offset;
@@ -90,41 +88,8 @@ public:
     }
 
     std::string GetName() const {
-        return std::string(TextureSamplerNames[static_cast<size_t>(stage)]) + '_' +
-               std::to_string(sampler_index);
-    }
-
-    std::string GetTypeString() const {
-        using Tegra::Shader::TextureType;
-        std::string glsl_type;
-
-        switch (type) {
-        case TextureType::Texture1D:
-            glsl_type = "sampler1D";
-            break;
-        case TextureType::Texture2D:
-            glsl_type = "sampler2D";
-            break;
-        case TextureType::Texture3D:
-            glsl_type = "sampler3D";
-            break;
-        case TextureType::TextureCube:
-            glsl_type = "samplerCube";
-            break;
-        default:
-            UNIMPLEMENTED();
-        }
-        if (is_array)
-            glsl_type += "Array";
-        return glsl_type;
-    }
-
-    Tegra::Shader::TextureType GetType() const {
-        return type;
-    }
-
-    bool IsArray() const {
-        return is_array;
+        return std::string(TextureSamplerNames[static_cast<size_t>(stage)]) + '[' +
+               std::to_string(sampler_index) + ']';
     }
 
     static std::string GetArrayName(Maxwell::ShaderStage stage) {
@@ -135,14 +100,11 @@ private:
     static constexpr std::array<const char*, Maxwell::MaxShaderStage> TextureSamplerNames = {
         "tex_vs", "tex_tessc", "tex_tesse", "tex_gs", "tex_fs",
     };
-
     /// Offset in TSC memory from which to read the sampler object, as specified by the sampling
     /// instruction.
     size_t offset;
-    Maxwell::ShaderStage stage;      ///< Shader stage where this sampler was used.
-    size_t sampler_index;            ///< Value used to index into the generated GLSL sampler array.
-    Tegra::Shader::TextureType type; ///< The type used to sample this texture (Texture2D, etc)
-    bool is_array; ///< Whether the texture is being sampled as an array texture or not.
+    Maxwell::ShaderStage stage; ///< Shader stage where this sampler was used.
+    size_t sampler_index;       ///< Value used to index into the generated GLSL sampler array.
 };
 
 struct ShaderEntries {
@@ -153,8 +115,8 @@ struct ShaderEntries {
 using ProgramResult = std::pair<std::string, ShaderEntries>;
 
 struct ShaderSetup {
-    ShaderSetup(const ProgramCode& program_code) {
-        program.code = program_code;
+    explicit ShaderSetup(ProgramCode program_code) {
+        program.code = std::move(program_code);
     }
 
     struct {
@@ -173,8 +135,8 @@ struct ShaderSetup {
     }
 
     /// Used in scenarios where we have a dual vertex shaders
-    void SetProgramB(const ProgramCode& program_b) {
-        program.code_b = program_b;
+    void SetProgramB(ProgramCode program_b) {
+        program.code_b = std::move(program_b);
         has_program_b = true;
     }
 
@@ -184,13 +146,18 @@ struct ShaderSetup {
 
 private:
     u64 GetNewHash() const {
+        size_t hash = 0;
+
+        const u64 hash_a = Common::ComputeHash64(program.code.data(), program.code.size());
+        boost::hash_combine(hash, hash_a);
+
         if (has_program_b) {
             // Compute hash over dual shader programs
-            return Common::ComputeHash64(&program, sizeof(program));
-        } else {
-            // Compute hash over a single shader program
-            return Common::ComputeHash64(&program.code, program.code.size());
+            const u64 hash_b = Common::ComputeHash64(program.code_b.data(), program.code_b.size());
+            boost::hash_combine(hash, hash_b);
         }
+
+        return hash;
     }
 
     u64 program_code_hash{};
@@ -229,20 +196,20 @@ ProgramResult GenerateVertexShader(const ShaderSetup& setup, const MaxwellVSConf
  */
 ProgramResult GenerateFragmentShader(const ShaderSetup& setup, const MaxwellFSConfig& config);
 
-} // namespace GLShader
+} // namespace OpenGL::GLShader
 
 namespace std {
 
 template <>
-struct hash<GLShader::MaxwellVSConfig> {
-    size_t operator()(const GLShader::MaxwellVSConfig& k) const {
+struct hash<OpenGL::GLShader::MaxwellVSConfig> {
+    size_t operator()(const OpenGL::GLShader::MaxwellVSConfig& k) const {
         return k.Hash();
     }
 };
 
 template <>
-struct hash<GLShader::MaxwellFSConfig> {
-    size_t operator()(const GLShader::MaxwellFSConfig& k) const {
+struct hash<OpenGL::GLShader::MaxwellFSConfig> {
+    size_t operator()(const OpenGL::GLShader::MaxwellFSConfig& k) const {
         return k.Hash();
     }
 };

src/video_core/renderer_opengl/gl_shader_manager.cpp

@@ -7,7 +7,7 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 
-namespace GLShader {
+namespace OpenGL::GLShader {
 
 namespace Impl {
 static void SetShaderUniformBlockBinding(GLuint shader, const char* name,
@@ -49,4 +49,4 @@ void MaxwellUniformData::SetFromRegs(const Maxwell3D::State::ShaderStageInfo& sh
     instance_id[0] = state.current_instance;
 }
 
-} // namespace GLShader
+} // namespace OpenGL::GLShader

src/video_core/renderer_opengl/gl_shader_manager.h

@@ -12,7 +12,7 @@
 #include "video_core/renderer_opengl/gl_shader_gen.h"
 #include "video_core/renderer_opengl/maxwell_to_gl.h"
 
-namespace GLShader {
+namespace OpenGL::GLShader {
 
 /// Number of OpenGL texture samplers that can be used in the fragment shader
 static constexpr size_t NumTextureSamplers = 32;
@@ -171,4 +171,4 @@ private:
     OGLPipeline pipeline;
 };
 
-} // namespace GLShader
+} // namespace OpenGL::GLShader

src/video_core/renderer_opengl/gl_shader_util.cpp

@@ -8,7 +8,7 @@
 #include "common/logging/log.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
 
-namespace GLShader {
+namespace OpenGL::GLShader {
 
 GLuint LoadShader(const char* source, GLenum type) {
     const char* debug_type;
@@ -47,4 +47,4 @@ GLuint LoadShader(const char* source, GLenum type) {
     return shader_id;
 }
 
-} // namespace GLShader
+} // namespace OpenGL::GLShader

src/video_core/renderer_opengl/gl_shader_util.h

@@ -10,7 +10,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 
-namespace GLShader {
+namespace OpenGL::GLShader {
 
 /**
  * Utility function to log the source code of a list of shaders.
@@ -89,4 +89,4 @@ GLuint LoadProgram(bool separable_program, T... shaders) {
     return program_id;
 }
 
-} // namespace GLShader
+} // namespace OpenGL::GLShader

src/video_core/renderer_opengl/gl_state.cpp

@@ -7,6 +7,8 @@
 #include "common/logging/log.h"
 #include "video_core/renderer_opengl/gl_state.h"
 
+namespace OpenGL {
+
 OpenGLState OpenGLState::cur_state;
 
 OpenGLState::OpenGLState() {
@@ -25,13 +27,17 @@ OpenGLState::OpenGLState() {
     color_mask.alpha_enabled = GL_TRUE;
 
     stencil.test_enabled = false;
-    stencil.test_func = GL_ALWAYS;
-    stencil.test_ref = 0;
-    stencil.test_mask = 0xFF;
-    stencil.write_mask = 0xFF;
-    stencil.action_depth_fail = GL_KEEP;
-    stencil.action_depth_pass = GL_KEEP;
-    stencil.action_stencil_fail = GL_KEEP;
+    auto reset_stencil = [](auto& config) {
+        config.test_func = GL_ALWAYS;
+        config.test_ref = 0;
+        config.test_mask = 0xFFFFFFFF;
+        config.write_mask = 0xFFFFFFFF;
+        config.action_depth_fail = GL_KEEP;
+        config.action_depth_pass = GL_KEEP;
+        config.action_stencil_fail = GL_KEEP;
+    };
+    reset_stencil(stencil.front);
+    reset_stencil(stencil.back);
 
     blend.enabled = true;
     blend.rgb_equation = GL_FUNC_ADD;
@@ -45,7 +51,8 @@ OpenGLState::OpenGLState() {
     blend.color.blue = 0.0f;
     blend.color.alpha = 0.0f;
 
-    logic_op = GL_COPY;
+    logic_op.enabled = false;
+    logic_op.operation = GL_COPY;
 
     for (auto& texture_unit : texture_units) {
         texture_unit.Reset();
@@ -126,33 +133,31 @@ void OpenGLState::Apply() const {
             glDisable(GL_STENCIL_TEST);
         }
     }
-
-    if (stencil.test_func != cur_state.stencil.test_func ||
-        stencil.test_ref != cur_state.stencil.test_ref ||
-        stencil.test_mask != cur_state.stencil.test_mask) {
-        glStencilFunc(stencil.test_func, stencil.test_ref, stencil.test_mask);
-    }
-
-    if (stencil.action_depth_fail != cur_state.stencil.action_depth_fail ||
-        stencil.action_depth_pass != cur_state.stencil.action_depth_pass ||
-        stencil.action_stencil_fail != cur_state.stencil.action_stencil_fail) {
-        glStencilOp(stencil.action_stencil_fail, stencil.action_depth_fail,
-                    stencil.action_depth_pass);
-    }
-
-    // Stencil mask
-    if (stencil.write_mask != cur_state.stencil.write_mask) {
-        glStencilMask(stencil.write_mask);
-    }
+    auto config_stencil = [](GLenum face, const auto& config, const auto& prev_config) {
+        if (config.test_func != prev_config.test_func || config.test_ref != prev_config.test_ref ||
+            config.test_mask != prev_config.test_mask) {
+            glStencilFuncSeparate(face, config.test_func, config.test_ref, config.test_mask);
+        }
+        if (config.action_depth_fail != prev_config.action_depth_fail ||
+            config.action_depth_pass != prev_config.action_depth_pass ||
+            config.action_stencil_fail != prev_config.action_stencil_fail) {
+            glStencilOpSeparate(face, config.action_stencil_fail, config.action_depth_fail,
+                                config.action_depth_pass);
+        }
+        if (config.write_mask != prev_config.write_mask) {
+            glStencilMaskSeparate(face, config.write_mask);
+        }
+    };
+    config_stencil(GL_FRONT, stencil.front, cur_state.stencil.front);
+    config_stencil(GL_BACK, stencil.back, cur_state.stencil.back);
 
     // Blending
     if (blend.enabled != cur_state.blend.enabled) {
         if (blend.enabled) {
+            ASSERT(!logic_op.enabled);
             glEnable(GL_BLEND);
-            glDisable(GL_COLOR_LOGIC_OP);
         } else {
             glDisable(GL_BLEND);
-            glEnable(GL_COLOR_LOGIC_OP);
         }
     }
 
@@ -176,8 +181,18 @@ void OpenGLState::Apply() const {
         glBlendEquationSeparate(blend.rgb_equation, blend.a_equation);
     }
 
-    if (logic_op != cur_state.logic_op) {
-        glLogicOp(logic_op);
+    // Logic Operation
+    if (logic_op.enabled != cur_state.logic_op.enabled) {
+        if (logic_op.enabled) {
+            ASSERT(!blend.enabled);
+            glEnable(GL_COLOR_LOGIC_OP);
+        } else {
+            glDisable(GL_COLOR_LOGIC_OP);
+        }
+    }
+
+    if (logic_op.operation != cur_state.logic_op.operation) {
+        glLogicOp(logic_op.operation);
     }
 
     // Textures
@@ -328,3 +343,5 @@ OpenGLState& OpenGLState::ResetFramebuffer(GLuint handle) {
     }
     return *this;
 }
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_state.h

@@ -9,6 +9,8 @@
 
 #include "video_core/engines/maxwell_3d.h"
 
+namespace OpenGL {
+
 using Regs = Tegra::Engines::Maxwell3D::Regs;
 
 namespace TextureUnits {
@@ -56,14 +58,16 @@ public:
     } color_mask; // GL_COLOR_WRITEMASK
 
     struct {
-        bool test_enabled;          // GL_STENCIL_TEST
-        GLenum test_func;           // GL_STENCIL_FUNC
-        GLint test_ref;             // GL_STENCIL_REF
-        GLuint test_mask;           // GL_STENCIL_VALUE_MASK
-        GLuint write_mask;          // GL_STENCIL_WRITEMASK
-        GLenum action_stencil_fail; // GL_STENCIL_FAIL
-        GLenum action_depth_fail;   // GL_STENCIL_PASS_DEPTH_FAIL
-        GLenum action_depth_pass;   // GL_STENCIL_PASS_DEPTH_PASS
+        bool test_enabled; // GL_STENCIL_TEST
+        struct {
+            GLenum test_func;           // GL_STENCIL_FUNC
+            GLint test_ref;             // GL_STENCIL_REF
+            GLuint test_mask;           // GL_STENCIL_VALUE_MASK
+            GLuint write_mask;          // GL_STENCIL_WRITEMASK
+            GLenum action_stencil_fail; // GL_STENCIL_FAIL
+            GLenum action_depth_fail;   // GL_STENCIL_PASS_DEPTH_FAIL
+            GLenum action_depth_pass;   // GL_STENCIL_PASS_DEPTH_PASS
+        } front, back;
     } stencil;
 
     struct {
@@ -83,7 +87,10 @@ public:
         } color; // GL_BLEND_COLOR
     } blend;
 
-    GLenum logic_op; // GL_LOGIC_OP_MODE
+    struct {
+        bool enabled; // GL_LOGIC_OP_MODE
+        GLenum operation;
+    } logic_op;
 
     // 3 texture units - one for each that is used in PICA fragment shader emulation
     struct TextureUnit {
@@ -160,3 +167,5 @@ public:
 private:
     static OpenGLState cur_state;
 };
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_stream_buffer.cpp

@@ -9,6 +9,8 @@
 #include "video_core/renderer_opengl/gl_state.h"
 #include "video_core/renderer_opengl/gl_stream_buffer.h"
 
+namespace OpenGL {
+
 OGLStreamBuffer::OGLStreamBuffer(GLenum target, GLsizeiptr size, bool prefer_coherent)
     : gl_target(target), buffer_size(size) {
     gl_buffer.Create();
@@ -97,3 +99,5 @@ void OGLStreamBuffer::Unmap(GLsizeiptr size) {
 
     buffer_pos += size;
 }
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_stream_buffer.h

@@ -9,6 +9,8 @@
 #include "common/common_types.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 
+namespace OpenGL {
+
 class OGLStreamBuffer : private NonCopyable {
 public:
     explicit OGLStreamBuffer(GLenum target, GLsizeiptr size, bool prefer_coherent = false);
@@ -42,3 +44,5 @@ private:
     GLsizeiptr mapped_size = 0;
     u8* mapped_ptr = nullptr;
 };
+
+} // namespace OpenGL

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -10,6 +10,8 @@
 #include "common/logging/log.h"
 #include "video_core/engines/maxwell_3d.h"
 
+namespace OpenGL {
+
 using GLvec2 = std::array<GLfloat, 2>;
 using GLvec3 = std::array<GLfloat, 3>;
 using GLvec4 = std::array<GLfloat, 4>;
@@ -107,6 +109,8 @@ inline GLenum PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
     switch (topology) {
     case Maxwell::PrimitiveTopology::Points:
         return GL_POINTS;
+    case Maxwell::PrimitiveTopology::Lines:
+        return GL_LINES;
     case Maxwell::PrimitiveTopology::LineStrip:
         return GL_LINE_STRIP;
     case Maxwell::PrimitiveTopology::Triangles:
@@ -291,6 +295,30 @@ inline GLenum ComparisonOp(Maxwell::ComparisonOp comparison) {
     return {};
 }
 
+inline GLenum StencilOp(Maxwell::StencilOp stencil) {
+    switch (stencil) {
+    case Maxwell::StencilOp::Keep:
+        return GL_KEEP;
+    case Maxwell::StencilOp::Zero:
+        return GL_ZERO;
+    case Maxwell::StencilOp::Replace:
+        return GL_REPLACE;
+    case Maxwell::StencilOp::Incr:
+        return GL_INCR;
+    case Maxwell::StencilOp::Decr:
+        return GL_DECR;
+    case Maxwell::StencilOp::Invert:
+        return GL_INVERT;
+    case Maxwell::StencilOp::IncrWrap:
+        return GL_INCR_WRAP;
+    case Maxwell::StencilOp::DecrWrap:
+        return GL_DECR_WRAP;
+    }
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented stencil op={}", static_cast<u32>(stencil));
+    UNREACHABLE();
+    return {};
+}
+
 inline GLenum FrontFace(Maxwell::Cull::FrontFace front_face) {
     switch (front_face) {
     case Maxwell::Cull::FrontFace::ClockWise:
@@ -317,4 +345,45 @@ inline GLenum CullFace(Maxwell::Cull::CullFace cull_face) {
     return {};
 }
 
+inline GLenum LogicOp(Maxwell::LogicOperation operation) {
+    switch (operation) {
+    case Maxwell::LogicOperation::Clear:
+        return GL_CLEAR;
+    case Maxwell::LogicOperation::And:
+        return GL_AND;
+    case Maxwell::LogicOperation::AndReverse:
+        return GL_AND_REVERSE;
+    case Maxwell::LogicOperation::Copy:
+        return GL_COPY;
+    case Maxwell::LogicOperation::AndInverted:
+        return GL_AND_INVERTED;
+    case Maxwell::LogicOperation::NoOp:
+        return GL_NOOP;
+    case Maxwell::LogicOperation::Xor:
+        return GL_XOR;
+    case Maxwell::LogicOperation::Or:
+        return GL_OR;
+    case Maxwell::LogicOperation::Nor:
+        return GL_NOR;
+    case Maxwell::LogicOperation::Equiv:
+        return GL_EQUIV;
+    case Maxwell::LogicOperation::Invert:
+        return GL_INVERT;
+    case Maxwell::LogicOperation::OrReverse:
+        return GL_OR_REVERSE;
+    case Maxwell::LogicOperation::CopyInverted:
+        return GL_COPY_INVERTED;
+    case Maxwell::LogicOperation::OrInverted:
+        return GL_OR_INVERTED;
+    case Maxwell::LogicOperation::Nand:
+        return GL_NAND;
+    case Maxwell::LogicOperation::Set:
+        return GL_SET;
+    }
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented logic operation={}", static_cast<u32>(operation));
+    UNREACHABLE();
+    return {};
+}
+
 } // namespace MaxwellToGL
+} // namespace OpenGL

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -16,9 +16,12 @@
 #include "core/memory.h"
 #include "core/settings.h"
 #include "core/tracer/recorder.h"
+#include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
 #include "video_core/utils.h"
 
+namespace OpenGL {
+
 static const char vertex_shader[] = R"(
 #version 150 core
 
@@ -130,7 +133,7 @@ void RendererOpenGL::SwapBuffers(boost::optional<const Tegra::FramebufferConfig&
         }
 
         // Load the framebuffer from memory, draw it to the screen, and swap buffers
-        LoadFBToScreenInfo(*framebuffer, screen_info);
+        LoadFBToScreenInfo(*framebuffer);
         DrawScreen();
         render_window.SwapBuffers();
     }
@@ -142,14 +145,12 @@ void RendererOpenGL::SwapBuffers(boost::optional<const Tegra::FramebufferConfig&
 
     // Restore the rasterizer state
     prev_state.Apply();
-    RefreshRasterizerSetting();
 }
 
 /**
  * Loads framebuffer from emulated memory into the active OpenGL texture.
  */
-void RendererOpenGL::LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer,
-                                        ScreenInfo& screen_info) {
+void RendererOpenGL::LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer) {
     const u32 bytes_per_pixel{Tegra::FramebufferConfig::BytesPerPixel(framebuffer.pixel_format)};
     const u64 size_in_bytes{framebuffer.stride * framebuffer.height * bytes_per_pixel};
     const VAddr framebuffer_addr{framebuffer.address + framebuffer.offset};
@@ -162,8 +163,7 @@ void RendererOpenGL::LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuf
     // only allows rows to have a memory alignement of 4.
     ASSERT(framebuffer.stride % 4 == 0);
 
-    if (!rasterizer->AccelerateDisplay(framebuffer, framebuffer_addr, framebuffer.stride,
-                                       screen_info)) {
+    if (!rasterizer->AccelerateDisplay(framebuffer, framebuffer_addr, framebuffer.stride)) {
         // Reset the screen info's display texture to its own permanent texture
         screen_info.display_texture = screen_info.texture.resource.handle;
 
@@ -276,6 +276,14 @@ void RendererOpenGL::InitOpenGLObjects() {
     LoadColorToActiveGLTexture(0, 0, 0, 0, screen_info.texture);
 }
 
+void RendererOpenGL::CreateRasterizer() {
+    if (rasterizer) {
+        return;
+    }
+
+    rasterizer = std::make_unique<RasterizerOpenGL>(render_window, screen_info);
+}
+
 void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
                                                  const Tegra::FramebufferConfig& framebuffer) {
 
@@ -463,11 +471,12 @@ bool RendererOpenGL::Init() {
     }
 
     InitOpenGLObjects();
-
-    RefreshRasterizerSetting();
+    CreateRasterizer();
 
     return true;
 }
 
 /// Shutdown the renderer
 void RendererOpenGL::ShutDown() {}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/renderer_opengl.h

@@ -16,6 +16,8 @@ namespace Core::Frontend {
 class EmuWindow;
 }
 
+namespace OpenGL {
+
 /// Structure used for storing information about the textures for the Switch screen
 struct TextureInfo {
     OGLTexture resource;
@@ -59,6 +61,8 @@ public:
 
 private:
     void InitOpenGLObjects();
+    void CreateRasterizer();
+
     void ConfigureFramebufferTexture(TextureInfo& texture,
                                      const Tegra::FramebufferConfig& framebuffer);
     void DrawScreen();
@@ -66,7 +70,7 @@ private:
     void UpdateFramerate();
 
     // Loads framebuffer from emulated memory into the display information structure
-    void LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer, ScreenInfo& screen_info);
+    void LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer);
     // Fills active OpenGL texture with the given RGBA color.
     void LoadColorToActiveGLTexture(u8 color_r, u8 color_g, u8 color_b, u8 color_a,
                                     const TextureInfo& texture);
@@ -96,3 +100,5 @@ private:
     Tegra::FramebufferConfig::TransformFlags framebuffer_transform_flags;
     MathUtil::Rectangle<int> framebuffer_crop_rect;
 };
+
+} // namespace OpenGL

src/video_core/video_core.cpp

@@ -10,7 +10,7 @@
 namespace VideoCore {
 
 std::unique_ptr<RendererBase> CreateRenderer(Core::Frontend::EmuWindow& emu_window) {
-    return std::make_unique<RendererOpenGL>(emu_window);
+    return std::make_unique<OpenGL::RendererOpenGL>(emu_window);
 }
 
 } // namespace VideoCore

src/yuzu/configuration/config.cpp

@@ -83,7 +83,8 @@ void Config::ReadValues() {
 
     qt_config->beginGroup("Renderer");
     Settings::values.resolution_factor = qt_config->value("resolution_factor", 1.0).toFloat();
-    Settings::values.toggle_framelimit = qt_config->value("toggle_framelimit", true).toBool();
+    Settings::values.use_frame_limit = qt_config->value("use_frame_limit", true).toBool();
+    Settings::values.frame_limit = qt_config->value("frame_limit", 100).toInt();
     Settings::values.use_accurate_framebuffers =
         qt_config->value("use_accurate_framebuffers", false).toBool();
 
@@ -124,7 +125,7 @@ void Config::ReadValues() {
 
     qt_config->beginGroup("UIGameList");
     UISettings::values.show_unknown = qt_config->value("show_unknown", true).toBool();
-    UISettings::values.icon_size = qt_config->value("icon_size", 48).toUInt();
+    UISettings::values.icon_size = qt_config->value("icon_size", 64).toUInt();
     UISettings::values.row_1_text_id = qt_config->value("row_1_text_id", 0).toUInt();
     UISettings::values.row_2_text_id = qt_config->value("row_2_text_id", 3).toUInt();
     qt_config->endGroup();
@@ -203,7 +204,8 @@ void Config::SaveValues() {
 
     qt_config->beginGroup("Renderer");
     qt_config->setValue("resolution_factor", (double)Settings::values.resolution_factor);
-    qt_config->setValue("toggle_framelimit", Settings::values.toggle_framelimit);
+    qt_config->setValue("use_frame_limit", Settings::values.use_frame_limit);
+    qt_config->setValue("frame_limit", Settings::values.frame_limit);
     qt_config->setValue("use_accurate_framebuffers", Settings::values.use_accurate_framebuffers);
 
     // Cast to double because Qt's written float values are not human-readable

src/yuzu/configuration/configure_graphics.cpp

@@ -12,6 +12,10 @@ ConfigureGraphics::ConfigureGraphics(QWidget* parent)
 
     ui->setupUi(this);
     this->setConfiguration();
+
+    ui->frame_limit->setEnabled(Settings::values.use_frame_limit);
+    connect(ui->toggle_frame_limit, &QCheckBox::stateChanged, ui->frame_limit,
+            &QSpinBox::setEnabled);
 }
 
 ConfigureGraphics::~ConfigureGraphics() = default;
@@ -58,13 +62,15 @@ Resolution FromResolutionFactor(float factor) {
 void ConfigureGraphics::setConfiguration() {
     ui->resolution_factor_combobox->setCurrentIndex(
         static_cast<int>(FromResolutionFactor(Settings::values.resolution_factor)));
-    ui->toggle_framelimit->setChecked(Settings::values.toggle_framelimit);
+    ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit);
+    ui->frame_limit->setValue(Settings::values.frame_limit);
     ui->use_accurate_framebuffers->setChecked(Settings::values.use_accurate_framebuffers);
 }
 
 void ConfigureGraphics::applyConfiguration() {
     Settings::values.resolution_factor =
         ToResolutionFactor(static_cast<Resolution>(ui->resolution_factor_combobox->currentIndex()));
-    Settings::values.toggle_framelimit = ui->toggle_framelimit->isChecked();
+    Settings::values.use_frame_limit = ui->toggle_frame_limit->isChecked();
+    Settings::values.frame_limit = ui->frame_limit->value();
     Settings::values.use_accurate_framebuffers = ui->use_accurate_framebuffers->isChecked();
 }

src/yuzu/configuration/configure_graphics.ui

@@ -23,11 +23,31 @@
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_2">
         <item>
-         <widget class="QCheckBox" name="toggle_framelimit">
-          <property name="text">
-           <string>Limit framerate</string>
-          </property>
-         </widget>
+          <layout class="QHBoxLayout" name="horizontalLayout_2">
+            <item>
+              <widget class="QCheckBox" name="toggle_frame_limit">
+                <property name="text">
+                  <string>Limit Speed Percent</string>
+                </property>
+              </widget>
+            </item>
+            <item>
+              <widget class="QSpinBox" name="frame_limit">
+                <property name="suffix">
+                  <string>%</string>
+                </property>
+                <property name="minimum">
+                  <number>1</number>
+                </property>
+                <property name="maximum">
+                  <number>9999</number>
+                </property>
+                <property name="value">
+                  <number>100</number>
+                </property>
+              </widget>
+            </item>
+          </layout>
         </item>
         <item>
          <widget class="QCheckBox" name="use_accurate_framebuffers">

src/yuzu/configuration/configure_input.ui

@@ -29,24 +29,6 @@
        </property>
        <layout class="QGridLayout" name="gridLayout_6">
         <item row="0" column="0">
-         <layout class="QVBoxLayout" name="buttonMiscPlusVerticalLayout">
-          <item>
-           <widget class="QLabel" name="labelPlus">
-            <property name="text">
-             <string>Plus:</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QPushButton" name="buttonPlus">
-            <property name="text">
-             <string/>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
-        <item row="0" column="1">
          <layout class="QVBoxLayout" name="buttonMiscMinusVerticalLayout">
           <item>
            <widget class="QLabel" name="labelMinus">
@@ -64,6 +46,24 @@
           </item>
          </layout>
         </item>
+        <item row="0" column="1">
+         <layout class="QVBoxLayout" name="buttonMiscPlusVerticalLayout">
+          <item>
+           <widget class="QLabel" name="labelPlus">
+            <property name="text">
+             <string>Plus:</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="buttonPlus">
+            <property name="text">
+             <string/>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
         <item row="1" column="0">
          <layout class="QVBoxLayout" name="buttonMiscHomeVerticalLayout">
           <item>

src/yuzu/game_list.cpp

@@ -16,6 +16,7 @@
 #include "common/string_util.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
+#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/loader/loader.h"
@@ -326,7 +327,7 @@ void GameList::PopupContextMenu(const QPoint& menu_location) {
     QAction* open_save_location = context_menu.addAction(tr("Open Save Data Location"));
     open_save_location->setEnabled(program_id != 0);
     connect(open_save_location, &QAction::triggered,
-            [&]() { emit OpenSaveFolderRequested(program_id); });
+            [&]() { emit OpenFolderRequested(program_id, GameListOpenTarget::SaveData); });
     context_menu.exec(tree_view->viewport()->mapToGlobal(menu_location));
 }
 

src/yuzu/game_list.h

@@ -21,6 +21,8 @@
 
 class GameListWorker;
 
+enum class GameListOpenTarget { SaveData };
+
 class GameList : public QWidget {
     Q_OBJECT
 
@@ -76,7 +78,7 @@ public:
 signals:
     void GameChosen(QString game_path);
     void ShouldCancelWorker();
-    void OpenSaveFolderRequested(u64 program_id);
+    void OpenFolderRequested(u64 program_id, GameListOpenTarget target);
 
 private slots:
     void onTextChanged(const QString& newText);
@@ -99,3 +101,5 @@ private:
     GameListWorker* current_worker = nullptr;
     QFileSystemWatcher* watcher = nullptr;
 };
+
+Q_DECLARE_METATYPE(GameListOpenTarget);

src/yuzu/game_list_p.h

@@ -6,12 +6,15 @@
 
 #include <array>
 #include <atomic>
+#include <map>
+#include <memory>
 #include <utility>
 #include <QImage>
 #include <QRunnable>
 #include <QStandardItem>
 #include <QString>
 #include "common/string_util.h"
+#include "core/file_sys/content_archive.h"
 #include "ui_settings.h"
 #include "yuzu/util/util.h"
 

src/yuzu/main.cpp

@@ -27,7 +27,10 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/crypto/key_manager.h"
+#include "core/file_sys/bis_factory.h"
 #include "core/file_sys/card_image.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/loader/loader.h"
@@ -213,6 +216,14 @@ void GMainWindow::InitializeRecentFileMenuActions() {
 
         ui.menu_recent_files->addAction(actions_recent_files[i]);
     }
+    ui.menu_recent_files->addSeparator();
+    QAction* action_clear_recent_files = new QAction(this);
+    action_clear_recent_files->setText(tr("Clear Recent Files"));
+    connect(action_clear_recent_files, &QAction::triggered, this, [this] {
+        UISettings::values.recent_files.clear();
+        UpdateRecentFiles();
+    });
+    ui.menu_recent_files->addAction(action_clear_recent_files);
 
     UpdateRecentFiles();
 }
@@ -221,11 +232,16 @@ void GMainWindow::InitializeHotkeys() {
     hotkey_registry.RegisterHotkey("Main Window", "Load File", QKeySequence::Open);
     hotkey_registry.RegisterHotkey("Main Window", "Start Emulation");
     hotkey_registry.RegisterHotkey("Main Window", "Continue/Pause", QKeySequence(Qt::Key_F4));
+    hotkey_registry.RegisterHotkey("Main Window", "Restart", QKeySequence(Qt::Key_F5));
     hotkey_registry.RegisterHotkey("Main Window", "Fullscreen", QKeySequence::FullScreen);
     hotkey_registry.RegisterHotkey("Main Window", "Exit Fullscreen", QKeySequence(Qt::Key_Escape),
                                    Qt::ApplicationShortcut);
     hotkey_registry.RegisterHotkey("Main Window", "Toggle Speed Limit", QKeySequence("CTRL+Z"),
                                    Qt::ApplicationShortcut);
+    hotkey_registry.RegisterHotkey("Main Window", "Increase Speed Limit", QKeySequence("+"),
+                                   Qt::ApplicationShortcut);
+    hotkey_registry.RegisterHotkey("Main Window", "Decrease Speed Limit", QKeySequence("-"),
+                                   Qt::ApplicationShortcut);
     hotkey_registry.LoadHotkeys();
 
     connect(hotkey_registry.GetHotkey("Main Window", "Load File", this), &QShortcut::activated,
@@ -242,6 +258,12 @@ void GMainWindow::InitializeHotkeys() {
                     }
                 }
             });
+    connect(hotkey_registry.GetHotkey("Main Window", "Restart", this), &QShortcut::activated, this,
+            [this] {
+                if (!Core::System::GetInstance().IsPoweredOn())
+                    return;
+                BootGame(QString(game_path));
+            });
     connect(hotkey_registry.GetHotkey("Main Window", "Fullscreen", render_window),
             &QShortcut::activated, ui.action_Fullscreen, &QAction::trigger);
     connect(hotkey_registry.GetHotkey("Main Window", "Fullscreen", render_window),
@@ -255,9 +277,24 @@ void GMainWindow::InitializeHotkeys() {
             });
     connect(hotkey_registry.GetHotkey("Main Window", "Toggle Speed Limit", this),
             &QShortcut::activated, this, [&] {
-                Settings::values.toggle_framelimit = !Settings::values.toggle_framelimit;
+                Settings::values.use_frame_limit = !Settings::values.use_frame_limit;
                 UpdateStatusBar();
             });
+    constexpr u16 SPEED_LIMIT_STEP = 5;
+    connect(hotkey_registry.GetHotkey("Main Window", "Increase Speed Limit", this),
+            &QShortcut::activated, this, [&] {
+                if (Settings::values.frame_limit < 9999 - SPEED_LIMIT_STEP) {
+                    Settings::values.frame_limit += SPEED_LIMIT_STEP;
+                    UpdateStatusBar();
+                }
+            });
+    connect(hotkey_registry.GetHotkey("Main Window", "Decrease Speed Limit", this),
+            &QShortcut::activated, this, [&] {
+                if (Settings::values.frame_limit > SPEED_LIMIT_STEP) {
+                    Settings::values.frame_limit -= SPEED_LIMIT_STEP;
+                    UpdateStatusBar();
+                }
+            });
 }
 
 void GMainWindow::SetDefaultUIGeometry() {
@@ -301,8 +338,7 @@ void GMainWindow::RestoreUIState() {
 
 void GMainWindow::ConnectWidgetEvents() {
     connect(game_list, &GameList::GameChosen, this, &GMainWindow::OnGameListLoadFile);
-    connect(game_list, &GameList::OpenSaveFolderRequested, this,
-            &GMainWindow::OnGameListOpenSaveFolder);
+    connect(game_list, &GameList::OpenFolderRequested, this, &GMainWindow::OnGameListOpenFolder);
 
     connect(this, &GMainWindow::EmulationStarting, render_window,
             &GRenderWindow::OnEmulationStarting);
@@ -326,6 +362,7 @@ void GMainWindow::ConnectMenuEvents() {
     connect(ui.action_Start, &QAction::triggered, this, &GMainWindow::OnStartGame);
     connect(ui.action_Pause, &QAction::triggered, this, &GMainWindow::OnPauseGame);
     connect(ui.action_Stop, &QAction::triggered, this, &GMainWindow::OnStopGame);
+    connect(ui.action_Restart, &QAction::triggered, this, [this] { BootGame(QString(game_path)); });
     connect(ui.action_Configure, &QAction::triggered, this, &GMainWindow::OnConfigure);
 
     // View
@@ -475,6 +512,8 @@ bool GMainWindow::LoadROM(const QString& filename) {
         }
         return false;
     }
+    game_path = filename;
+
     Core::Telemetry().AddField(Telemetry::FieldType::App, "Frontend", "Qt");
     return true;
 }
@@ -533,6 +572,7 @@ void GMainWindow::ShutdownGame() {
     ui.action_Start->setText(tr("Start"));
     ui.action_Pause->setEnabled(false);
     ui.action_Stop->setEnabled(false);
+    ui.action_Restart->setEnabled(false);
     render_window->hide();
     game_list->show();
     game_list->setFilterFocus();
@@ -545,6 +585,8 @@ void GMainWindow::ShutdownGame() {
     emu_frametime_label->setVisible(false);
 
     emulation_running = false;
+
+    game_path.clear();
 }
 
 void GMainWindow::StoreRecentFile(const QString& filename) {
@@ -582,8 +624,37 @@ void GMainWindow::OnGameListLoadFile(QString game_path) {
     BootGame(game_path);
 }
 
-void GMainWindow::OnGameListOpenSaveFolder(u64 program_id) {
-    UNIMPLEMENTED();
+void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target) {
+    std::string path;
+    std::string open_target;
+    switch (target) {
+    case GameListOpenTarget::SaveData: {
+        open_target = "Save Data";
+        const std::string nand_dir = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir);
+        ASSERT(program_id != 0);
+        // TODO(tech4me): Update this to work with arbitrary user profile
+        // Refer to core/hle/service/acc/profile_manager.cpp ProfileManager constructor
+        constexpr u128 user_id = {1, 0};
+        path = nand_dir + FileSys::SaveDataFactory::GetFullPath(FileSys::SaveDataSpaceId::NandUser,
+                                                                FileSys::SaveDataType::SaveData,
+                                                                program_id, user_id, 0);
+        break;
+    }
+    default:
+        UNIMPLEMENTED();
+    }
+
+    const QString qpath = QString::fromStdString(path);
+
+    const QDir dir(qpath);
+    if (!dir.exists()) {
+        QMessageBox::warning(this,
+                             tr("Error Opening %1 Folder").arg(QString::fromStdString(open_target)),
+                             tr("Folder does not exist!"));
+        return;
+    }
+    LOG_INFO(Frontend, "Opening {} path for program_id={:016x}", open_target, program_id);
+    QDesktopServices::openUrl(QUrl::fromLocalFile(qpath));
 }
 
 void GMainWindow::OnMenuLoadFile() {
@@ -809,6 +880,7 @@ void GMainWindow::OnPauseGame() {
     ui.action_Start->setEnabled(true);
     ui.action_Pause->setEnabled(false);
     ui.action_Stop->setEnabled(true);
+    ui.action_Restart->setEnabled(true);
 }
 
 void GMainWindow::OnStopGame() {
@@ -910,7 +982,13 @@ void GMainWindow::UpdateStatusBar() {
 
     auto results = Core::System::GetInstance().GetAndResetPerfStats();
 
-    emu_speed_label->setText(tr("Speed: %1%").arg(results.emulation_speed * 100.0, 0, 'f', 0));
+    if (Settings::values.use_frame_limit) {
+        emu_speed_label->setText(tr("Speed: %1% / %2%")
+                                     .arg(results.emulation_speed * 100.0, 0, 'f', 0)
+                                     .arg(Settings::values.frame_limit));
+    } else {
+        emu_speed_label->setText(tr("Speed: %1%").arg(results.emulation_speed * 100.0, 0, 'f', 0));
+    }
     game_fps_label->setText(tr("Game: %1 FPS").arg(results.game_fps, 0, 'f', 0));
     emu_frametime_label->setText(tr("Frame: %1 ms").arg(results.frametime * 1000.0, 0, 'f', 2));
 

src/yuzu/main.h

@@ -21,6 +21,7 @@ class GRenderWindow;
 class MicroProfileDialog;
 class ProfilerWidget;
 class WaitTreeWidget;
+enum class GameListOpenTarget;
 
 namespace Tegra {
 class DebugContext;
@@ -122,7 +123,7 @@ private slots:
     void OnStopGame();
     /// Called whenever a user selects a game in the game list widget.
     void OnGameListLoadFile(QString game_path);
-    void OnGameListOpenSaveFolder(u64 program_id);
+    void OnGameListOpenFolder(u64 program_id, GameListOpenTarget target);
     void OnMenuLoadFile();
     void OnMenuLoadFolder();
     void OnMenuInstallToNAND();
@@ -161,6 +162,8 @@ private:
     // Whether emulation is currently running in yuzu.
     bool emulation_running = false;
     std::unique_ptr<EmuThread> emu_thread;
+    // The path to the game currently running
+    QString game_path;
 
     // FS
     FileSys::VirtualFilesystem vfs;

src/yuzu/main.ui

@@ -211,6 +211,14 @@
     <string>Fullscreen</string>
    </property>
   </action>
+   <action name="action_Restart">
+     <property name="enabled">
+       <bool>false</bool>
+     </property>
+     <property name="text">
+       <string>Restart</string>
+     </property>
+   </action>
   </widget>
  <resources/>
 </ui>

src/yuzu_cmd/config.cpp

@@ -96,8 +96,9 @@ void Config::ReadValues() {
     // Renderer
     Settings::values.resolution_factor =
         (float)sdl2_config->GetReal("Renderer", "resolution_factor", 1.0);
-    Settings::values.toggle_framelimit =
-        sdl2_config->GetBoolean("Renderer", "toggle_framelimit", true);
+    Settings::values.use_frame_limit = sdl2_config->GetBoolean("Renderer", "use_frame_limit", true);
+    Settings::values.frame_limit =
+        static_cast<u16>(sdl2_config->GetInteger("Renderer", "frame_limit", 100));
     Settings::values.use_accurate_framebuffers =
         sdl2_config->GetBoolean("Renderer", "use_accurate_framebuffers", false);
 

src/yuzu_cmd/default_ini.h

@@ -102,6 +102,14 @@ resolution_factor =
 # 0 (default): Off, 1: On
 use_vsync =
 
+# Turns on the frame limiter, which will limit frames output to the target game speed
+# 0: Off, 1: On (default)
+use_frame_limit =
+
+# Limits the speed of the game to run no faster than this value as a percentage of target speed
+# 1 - 9999: Speed limit as a percentage of target game speed. 100 (default)
+frame_limit =
+
 # Whether to use accurate framebuffers
 # 0 (default): Off (fast), 1 : On (slow)
 use_accurate_framebuffers =
@@ -132,10 +140,6 @@ custom_bottom_top =
 custom_bottom_right =
 custom_bottom_bottom =
 
-# Whether to toggle frame limiter on or off.
-# 0: Off, 1 (default): On
-toggle_framelimit =
-
 # Swaps the prominent screen with the other screen.
 # For example, if Single Screen is chosen, setting this to 1 will display the bottom screen instead of the top screen.
 # 0 (default): Top Screen is prominent, 1: Bottom Screen is prominent