Merge 9cd9af61cf into 028d90eb79

Avoids proliferating includes through other headers, lessening the total
amount of files that need to be rebuilt if those headers are changed.
This also resolves a few indirect inclusions.

appveyor.yml

@@ -53,7 +53,7 @@ build_script:
           # https://www.appveyor.com/docs/build-phase
           msbuild msvc_build/yuzu.sln /maxcpucount /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
         } else {
-          C:\msys64\usr\bin\bash.exe -lc 'mingw32-make -C mingw_build/ 2>&1'
+          C:\msys64\usr\bin\bash.exe -lc 'mingw32-make -j4 -C mingw_build/ 2>&1'
         }
 
 after_build:

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] = static_cast<s16>(std::clamp(out[0][ch], -32768.0, 32767.0));
+            signal[i * 2 + ch] = std::clamp(out[0][ch], -32768.0, 32767.0);
         }
     }
 }

src/common/bit_field.h

@@ -178,7 +178,8 @@ public:
         return ExtractValue(storage);
     }
 
-    constexpr explicit operator bool() const {
+    // TODO: we may want to change this to explicit operator bool() if it's bug-free in VS2015
+    constexpr FORCE_INLINE bool ToBool() 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 = {};
+    CONSOLE_SCREEN_BUFFER_INFO original_info = {0};
     GetConsoleScreenBufferInfo(console_handle, &original_info);
 
     WORD color = 0;

src/common/telemetry.cpp

@@ -3,15 +3,8 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <cstring>
-#include "common/assert.h"
-#include "common/scm_rev.h"
 #include "common/telemetry.h"
 
-#ifdef ARCHITECTURE_x86_64
-#include "common/x64/cpu_detect.h"
-#endif
-
 namespace Telemetry {
 
 void FieldCollection::Accept(VisitorInterface& visitor) const {
@@ -44,62 +37,4 @@ template class Field<std::string>;
 template class Field<const char*>;
 template class Field<std::chrono::microseconds>;
 
-#ifdef ARCHITECTURE_x86_64
-static const char* CpuVendorToStr(Common::CPUVendor vendor) {
-    switch (vendor) {
-    case Common::CPUVendor::INTEL:
-        return "Intel";
-    case Common::CPUVendor::AMD:
-        return "Amd";
-    case Common::CPUVendor::OTHER:
-        return "Other";
-    }
-    UNREACHABLE();
-}
-#endif
-
-void AppendBuildInfo(FieldCollection& fc) {
-    const bool is_git_dirty{std::strstr(Common::g_scm_desc, "dirty") != nullptr};
-    fc.AddField(FieldType::App, "Git_IsDirty", is_git_dirty);
-    fc.AddField(FieldType::App, "Git_Branch", Common::g_scm_branch);
-    fc.AddField(FieldType::App, "Git_Revision", Common::g_scm_rev);
-    fc.AddField(FieldType::App, "BuildDate", Common::g_build_date);
-    fc.AddField(FieldType::App, "BuildName", Common::g_build_name);
-}
-
-void AppendCPUInfo(FieldCollection& fc) {
-#ifdef ARCHITECTURE_x86_64
-    fc.AddField(FieldType::UserSystem, "CPU_Model", Common::GetCPUCaps().cpu_string);
-    fc.AddField(FieldType::UserSystem, "CPU_BrandString", Common::GetCPUCaps().brand_string);
-    fc.AddField(FieldType::UserSystem, "CPU_Vendor", CpuVendorToStr(Common::GetCPUCaps().vendor));
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AES", Common::GetCPUCaps().aes);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AVX", Common::GetCPUCaps().avx);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AVX2", Common::GetCPUCaps().avx2);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_BMI1", Common::GetCPUCaps().bmi1);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_BMI2", Common::GetCPUCaps().bmi2);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_FMA", Common::GetCPUCaps().fma);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_FMA4", Common::GetCPUCaps().fma4);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE", Common::GetCPUCaps().sse);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE2", Common::GetCPUCaps().sse2);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE3", Common::GetCPUCaps().sse3);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSSE3", Common::GetCPUCaps().ssse3);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE41", Common::GetCPUCaps().sse4_1);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE42", Common::GetCPUCaps().sse4_2);
-#else
-    fc.AddField(FieldType::UserSystem, "CPU_Model", "Other");
-#endif
-}
-
-void AppendOSInfo(FieldCollection& fc) {
-#ifdef __APPLE__
-    fc.AddField(FieldType::UserSystem, "OsPlatform", "Apple");
-#elif defined(_WIN32)
-    fc.AddField(FieldType::UserSystem, "OsPlatform", "Windows");
-#elif defined(__linux__) || defined(linux) || defined(__linux)
-    fc.AddField(FieldType::UserSystem, "OsPlatform", "Linux");
-#else
-    fc.AddField(FieldType::UserSystem, "OsPlatform", "Unknown");
-#endif
-}
-
 } // namespace Telemetry

src/common/telemetry.h

@@ -180,16 +180,4 @@ struct NullVisitor : public VisitorInterface {
     void Complete() override {}
 };
 
-/// Appends build-specific information to the given FieldCollection,
-/// such as branch name, revision hash, etc.
-void AppendBuildInfo(FieldCollection& fc);
-
-/// Appends CPU-specific information to the given FieldCollection,
-/// such as instruction set extensions, etc.
-void AppendCPUInfo(FieldCollection& fc);
-
-/// Appends OS-specific information to the given FieldCollection,
-/// such as platform name, etc.
-void AppendOSInfo(FieldCollection& fc);
-
 } // namespace Telemetry

src/core/core.h

@@ -187,13 +187,6 @@ public:
         return current_process;
     }
 
-    /// Gets the name of the current game
-    Loader::ResultStatus GetGameName(std::string& out) const {
-        if (app_loader == nullptr)
-            return Loader::ResultStatus::ErrorNotInitialized;
-        return app_loader->ReadTitle(out);
-    }
-
     PerfStats perf_stats;
     FrameLimiter frame_limiter;
 

src/core/file_sys/bis_factory.cpp

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

src/core/file_sys/bis_factory.h

@@ -5,11 +5,12 @@
 #pragma once
 
 #include <memory>
-#include "core/loader/loader.h"
-#include "registered_cache.h"
+#include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
+class RegisteredCache;
+
 /// File system interface to the Built-In Storage
 /// This is currently missing accessors to BIS partitions, but seemed like a good place for the NAND
 /// registered caches.

src/core/file_sys/content_archive.cpp

@@ -9,6 +9,7 @@
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"
 #include "core/file_sys/content_archive.h"
+#include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/loader/loader.h"

src/core/file_sys/content_archive.h

@@ -14,7 +14,6 @@
 #include "common/swap.h"
 #include "control_metadata.h"
 #include "core/crypto/key_manager.h"
-#include "core/file_sys/partition_filesystem.h"
 #include "core/loader/loader.h"
 
 namespace FileSys {
@@ -27,7 +26,6 @@ enum class NCAContentType : u8 {
     Control = 2,
     Manual = 3,
     Data = 4,
-    Data_Unknown5 = 5, ///< Seems to be used on some system archives
 };
 
 enum class NCASectionCryptoType : u8 {

src/core/file_sys/nca_metadata.cpp

@@ -3,9 +3,9 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
+#include <utility>
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
-#include "common/swap.h"
 #include "content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 

src/core/file_sys/nca_metadata.h

@@ -4,10 +4,9 @@
 
 #pragma once
 
-#include <cstring>
+#include <array>
 #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/registered_cache.cpp

@@ -77,13 +77,12 @@ static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
     case NCAContentType::Control:
         return ContentRecordType::Control;
     case NCAContentType::Data:
-    case NCAContentType::Data_Unknown5:
         return ContentRecordType::Data;
     case NCAContentType::Manual:
         // TODO(DarkLordZach): Peek at NCA contents to differentiate Manual and Legal.
         return ContentRecordType::Manual;
     default:
-        UNREACHABLE_MSG("Invalid NCAContentType={:02X}", static_cast<u8>(type));
+        UNREACHABLE();
     }
 }
 

src/core/file_sys/registered_cache.h

@@ -11,15 +11,14 @@
 #include <string>
 #include <vector>
 #include <boost/container/flat_map.hpp>
-#include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "content_archive.h"
+#include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
-class XCI;
 class CNMT;
+class XCI;
 
 using NcaID = std::array<u8, 0x10>;
 using RegisteredCacheParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;

src/core/file_sys/romfs_factory.cpp

@@ -2,61 +2,23 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <memory>
 #include "common/common_types.h"
 #include "common/logging/log.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 (app_loader.ReadRomFS(file) != Loader::ResultStatus::Success) {
+    if (Loader::ResultStatus::Success != app_loader.ReadRomFS(file)) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
     }
 }
 
-ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() {
+ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id) {
+    // TODO(DarkLordZach): Use title id.
     return MakeResult<VirtualFile>(file);
 }
 
-ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) {
-    switch (storage) {
-    case StorageId::NandSystem: {
-        const auto res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);
-        if (res == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        const auto romfs = res->GetRomFS();
-        if (romfs == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        return MakeResult<VirtualFile>(romfs);
-    }
-    case StorageId::NandUser: {
-        const auto res = Service::FileSystem::GetUserNANDContents()->GetEntry(title_id, type);
-        if (res == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        const auto romfs = res->GetRomFS();
-        if (romfs == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        return MakeResult<VirtualFile>(romfs);
-    }
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
-    }
-}
-
 } // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -4,35 +4,22 @@
 
 #pragma once
 
-#include <memory>
 #include "common/common_types.h"
 #include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
 namespace Loader {
 class AppLoader;
-} // namespace Loader
+}
 
 namespace FileSys {
 
-enum class ContentRecordType : u8;
-
-enum class StorageId : u8 {
-    None = 0,
-    Host = 1,
-    GameCard = 2,
-    NandSystem = 3,
-    NandUser = 4,
-    SdCard = 5,
-};
-
 /// File system interface to the RomFS archive
 class RomFSFactory {
 public:
     explicit RomFSFactory(Loader::AppLoader& app_loader);
 
-    ResultVal<VirtualFile> OpenCurrentProcess();
-    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type);
+    ResultVal<VirtualFile> Open(u64 title_id);
 
 private:
     VirtualFile file;

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) {
+                                         u128 user_id, u64 save_id) const {
     // 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

@@ -6,8 +6,10 @@
 
 #include <memory>
 #include <string>
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
 namespace FileSys {
@@ -49,11 +51,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

@@ -2,7 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <memory>
+#include <utility>
 #include "core/file_sys/sdmc_factory.h"
 
 namespace FileSys {

src/core/file_sys/vfs.cpp

@@ -8,7 +8,6 @@
 #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,8 +9,9 @@
 #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 {
 
@@ -18,8 +19,6 @@ 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/acc/acc.cpp

@@ -13,7 +13,7 @@
 #include "core/hle/service/acc/acc_su.h"
 #include "core/hle/service/acc/acc_u0.h"
 #include "core/hle/service/acc/acc_u1.h"
-#include "core/hle/service/acc/profile_manager.h"
+#include "core/settings.h"
 
 namespace Service::Account {
 // TODO: RE this structure
@@ -27,10 +27,13 @@ struct UserData {
 };
 static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");
 
+// TODO(ogniK): Generate a real user id based on username, md5(username) maybe?
+static UUID DEFAULT_USER_ID{1ull, 0ull};
+
 class IProfile final : public ServiceFramework<IProfile> {
 public:
     explicit IProfile(UUID user_id, ProfileManager& profile_manager)
-        : ServiceFramework("IProfile"), profile_manager(profile_manager), user_id(user_id) {
+        : ServiceFramework("IProfile"), user_id(user_id), profile_manager(profile_manager) {
         static const FunctionInfo functions[] = {
             {0, &IProfile::Get, "Get"},
             {1, &IProfile::GetBase, "GetBase"},
@@ -76,8 +79,8 @@ private:
         LOG_WARNING(Service_ACC, "(STUBBED) called");
         // smallest jpeg https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
         // TODO(mailwl): load actual profile image from disk, width 256px, max size 0x20000
-        constexpr u32 jpeg_size = 107;
-        static constexpr std::array<u8, jpeg_size> jpeg{
+        const u32 jpeg_size = 107;
+        static const std::array<u8, jpeg_size> jpeg{
             0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
             0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04,
             0x08, 0x06, 0x06, 0x05, 0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a,
@@ -87,7 +90,7 @@ private:
             0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
             0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
         };
-        ctx.WriteBuffer(jpeg);
+        ctx.WriteBuffer(jpeg.data(), jpeg_size);
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(jpeg_size);
@@ -202,8 +205,6 @@ Module::Interface::Interface(std::shared_ptr<Module> module,
     : ServiceFramework(name), module(std::move(module)),
       profile_manager(std::move(profile_manager)) {}
 
-Module::Interface::~Interface() = default;
-
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module = std::make_shared<Module>();
     auto profile_manager = std::make_shared<ProfileManager>();

src/core/hle/service/acc/acc.h

@@ -4,19 +4,17 @@
 
 #pragma once
 
+#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::Account {
 
-class ProfileManager;
-
 class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
         explicit Interface(std::shared_ptr<Module> module,
                            std::shared_ptr<ProfileManager> profile_manager, const char* name);
-        ~Interface() override;
 
         void GetUserCount(Kernel::HLERequestContext& ctx);
         void GetUserExistence(Kernel::HLERequestContext& ctx);

src/core/hle/service/acc/profile_manager.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <random>
 #include <boost/optional.hpp>
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
@@ -13,15 +12,6 @@ constexpr ResultCode ERROR_TOO_MANY_USERS(ErrorModule::Account, -1);
 constexpr ResultCode ERROR_USER_ALREADY_EXISTS(ErrorModule::Account, -2);
 constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);
 
-const UUID& UUID::Generate() {
-    std::random_device device;
-    std::mt19937 gen(device());
-    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-    uuid[0] = distribution(gen);
-    uuid[1] = distribution(gen);
-    return *this;
-}
-
 ProfileManager::ProfileManager() {
     // TODO(ogniK): Create the default user we have for now until loading/saving users is added
     auto user_uuid = UUID{1, 0};
@@ -35,7 +25,7 @@ boost::optional<size_t> ProfileManager::AddToProfiles(const ProfileInfo& user) {
     if (user_count >= MAX_USERS) {
         return boost::none;
     }
-    profiles[user_count] = user;
+    profiles[user_count] = std::move(user);
     return user_count++;
 }
 
@@ -53,7 +43,7 @@ bool ProfileManager::RemoveProfileAtIndex(size_t index) {
 }
 
 /// Helper function to register a user to the system
-ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
+ResultCode ProfileManager::AddUser(ProfileInfo user) {
     if (AddToProfiles(user) == boost::none) {
         return ERROR_TOO_MANY_USERS;
     }
@@ -62,7 +52,7 @@ ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
 
 /// Create a new user on the system. If the uuid of the user already exists, the user is not
 /// created.
-ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& username) {
+ResultCode ProfileManager::CreateNewUser(UUID uuid, std::array<u8, 0x20>& username) {
     if (user_count == MAX_USERS) {
         return ERROR_TOO_MANY_USERS;
     }
@@ -77,7 +67,7 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& usern
         return ERROR_USER_ALREADY_EXISTS;
     }
     ProfileInfo profile;
-    profile.user_uuid = uuid;
+    profile.user_uuid = std::move(uuid);
     profile.username = username;
     profile.data = {};
     profile.creation_time = 0x0;
@@ -89,7 +79,7 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& usern
 /// specifically by allowing an std::string for the username. This is required specifically since
 /// we're loading a string straight from the config
 ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username) {
-    ProfileUsername username_output;
+    std::array<u8, 0x20> username_output;
     if (username.size() > username_output.size()) {
         std::copy_n(username.begin(), username_output.size(), username_output.begin());
     } else {
@@ -112,7 +102,7 @@ boost::optional<size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
 }
 
 /// Returns a users profile index based on their profile
-boost::optional<size_t> ProfileManager::GetUserIndex(const ProfileInfo& user) const {
+boost::optional<size_t> ProfileManager::GetUserIndex(ProfileInfo user) const {
     return GetUserIndex(user.user_uuid);
 }
 
@@ -135,7 +125,7 @@ bool ProfileManager::GetProfileBase(UUID uuid, ProfileBase& profile) const {
 }
 
 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
-bool ProfileManager::GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const {
+bool ProfileManager::GetProfileBase(ProfileInfo user, ProfileBase& profile) const {
     return GetProfileBase(user.user_uuid, profile);
 }
 
@@ -178,8 +168,8 @@ void ProfileManager::CloseUser(UUID uuid) {
 }
 
 /// Gets all valid user ids on the system
-UserIDArray ProfileManager::GetAllUsers() const {
-    UserIDArray output;
+std::array<UUID, MAX_USERS> ProfileManager::GetAllUsers() const {
+    std::array<UUID, MAX_USERS> output;
     std::transform(profiles.begin(), profiles.end(), output.begin(),
                    [](const ProfileInfo& p) { return p.user_uuid; });
     return output;
@@ -187,8 +177,8 @@ UserIDArray ProfileManager::GetAllUsers() const {
 
 /// Get all the open users on the system and zero out the rest of the data. This is specifically
 /// needed for GetOpenUsers and we need to ensure the rest of the output buffer is zero'd out
-UserIDArray ProfileManager::GetOpenUsers() const {
-    UserIDArray output;
+std::array<UUID, MAX_USERS> ProfileManager::GetOpenUsers() const {
+    std::array<UUID, MAX_USERS> output;
     std::transform(profiles.begin(), profiles.end(), output.begin(), [](const ProfileInfo& p) {
         if (p.is_open)
             return p.user_uuid;
@@ -205,9 +195,9 @@ UUID ProfileManager::GetLastOpenedUser() const {
 
 /// Return the users profile base and the unknown arbitary data.
 bool ProfileManager::GetProfileBaseAndData(boost::optional<size_t> index, ProfileBase& profile,
-                                           ProfileData& data) const {
+                                           std::array<u8, MAX_DATA>& data) const {
     if (GetProfileBase(index, profile)) {
-        data = profiles[index.get()].data;
+        std::memcpy(data.data(), profiles[index.get()].data.data(), MAX_DATA);
         return true;
     }
     return false;
@@ -215,14 +205,14 @@ bool ProfileManager::GetProfileBaseAndData(boost::optional<size_t> index, Profil
 
 /// Return the users profile base and the unknown arbitary data.
 bool ProfileManager::GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
-                                           ProfileData& data) const {
+                                           std::array<u8, MAX_DATA>& data) const {
     auto idx = GetUserIndex(uuid);
     return GetProfileBaseAndData(idx, profile, data);
 }
 
 /// Return the users profile base and the unknown arbitary data.
-bool ProfileManager::GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
-                                           ProfileData& data) const {
+bool ProfileManager::GetProfileBaseAndData(ProfileInfo user, ProfileBase& profile,
+                                           std::array<u8, MAX_DATA>& data) const {
     return GetProfileBaseAndData(user.user_uuid, profile, data);
 }
 

src/core/hle/service/acc/profile_manager.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <array>
-
+#include <random>
 #include "boost/optional.hpp"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -14,21 +14,23 @@
 namespace Service::Account {
 constexpr size_t MAX_USERS = 8;
 constexpr size_t MAX_DATA = 128;
-constexpr u128 INVALID_UUID{{0, 0}};
+static const u128 INVALID_UUID = {0, 0};
 
 struct UUID {
     // UUIDs which are 0 are considered invalid!
     u128 uuid = INVALID_UUID;
     UUID() = default;
     explicit UUID(const u128& id) : uuid{id} {}
-    explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
-
+    explicit UUID(const u64 lo, const u64 hi) {
+        uuid[0] = lo;
+        uuid[1] = hi;
+    };
     explicit operator bool() const {
-        return uuid != INVALID_UUID;
+        return uuid[0] != INVALID_UUID[0] || uuid[1] != INVALID_UUID[1];
     }
 
     bool operator==(const UUID& rhs) const {
-        return uuid == rhs.uuid;
+        return std::tie(uuid[0], uuid[1]) == std::tie(rhs.uuid[0], rhs.uuid[1]);
     }
 
     bool operator!=(const UUID& rhs) const {
@@ -36,7 +38,15 @@ struct UUID {
     }
 
     // TODO(ogniK): Properly generate uuids based on RFC-4122
-    const UUID& Generate();
+    const UUID& Generate() {
+        std::random_device device;
+        std::mt19937 gen(device());
+        std::uniform_int_distribution<uint64_t> distribution(1,
+                                                             std::numeric_limits<uint64_t>::max());
+        uuid[0] = distribution(gen);
+        uuid[1] = distribution(gen);
+        return *this;
+    }
 
     // Set the UUID to {0,0} to be considered an invalid user
     void Invalidate() {
@@ -48,24 +58,20 @@ struct UUID {
 };
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
 
-using ProfileUsername = std::array<u8, 0x20>;
-using ProfileData = std::array<u8, MAX_DATA>;
-using UserIDArray = std::array<UUID, MAX_USERS>;
-
 /// This holds general information about a users profile. This is where we store all the information
 /// based on a specific user
 struct ProfileInfo {
     UUID user_uuid;
-    ProfileUsername username;
+    std::array<u8, 0x20> username;
     u64 creation_time;
-    ProfileData data; // TODO(ognik): Work out what this is
+    std::array<u8, MAX_DATA> data; // TODO(ognik): Work out what this is
     bool is_open;
 };
 
 struct ProfileBase {
     UUID user_uuid;
     u64_le timestamp;
-    ProfileUsername username;
+    std::array<u8, 0x20> username;
 
     // Zero out all the fields to make the profile slot considered "Empty"
     void Invalidate() {
@@ -82,26 +88,27 @@ static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase is an invalid size");
 class ProfileManager {
 public:
     ProfileManager(); // TODO(ogniK): Load from system save
-    ResultCode AddUser(const ProfileInfo& user);
-    ResultCode CreateNewUser(UUID uuid, const ProfileUsername& username);
+    ResultCode AddUser(ProfileInfo user);
+    ResultCode CreateNewUser(UUID uuid, std::array<u8, 0x20>& username);
     ResultCode CreateNewUser(UUID uuid, const std::string& username);
     boost::optional<size_t> GetUserIndex(const UUID& uuid) const;
-    boost::optional<size_t> GetUserIndex(const ProfileInfo& user) const;
+    boost::optional<size_t> GetUserIndex(ProfileInfo user) const;
     bool GetProfileBase(boost::optional<size_t> index, ProfileBase& profile) const;
     bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
-    bool GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const;
+    bool GetProfileBase(ProfileInfo user, ProfileBase& profile) const;
     bool GetProfileBaseAndData(boost::optional<size_t> index, ProfileBase& profile,
-                               ProfileData& data) const;
-    bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile, ProfileData& data) const;
-    bool GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
-                               ProfileData& data) const;
+                               std::array<u8, MAX_DATA>& data) const;
+    bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
+                               std::array<u8, MAX_DATA>& data) const;
+    bool GetProfileBaseAndData(ProfileInfo user, ProfileBase& profile,
+                               std::array<u8, MAX_DATA>& data) const;
     size_t GetUserCount() const;
     size_t GetOpenUserCount() const;
     bool UserExists(UUID uuid) const;
     void OpenUser(UUID uuid);
     void CloseUser(UUID uuid);
-    UserIDArray GetOpenUsers() const;
-    UserIDArray GetAllUsers() const;
+    std::array<UUID, MAX_USERS> GetOpenUsers() const;
+    std::array<UUID, MAX_USERS> GetAllUsers() const;
     UUID GetLastOpenedUser() const;
 
     bool CanSystemRegisterUser() const;
@@ -111,7 +118,7 @@ private:
     size_t user_count = 0;
     boost::optional<size_t> AddToProfiles(const ProfileInfo& profile);
     bool RemoveProfileAtIndex(size_t index);
-    UUID last_opened_user{INVALID_UUID};
+    UUID last_opened_user{0, 0};
 };
 
 }; // namespace Service::Account

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

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

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

@@ -9,12 +9,13 @@
 #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/registered_cache.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"
@@ -39,6 +40,8 @@ static FileSys::VirtualDir GetDirectoryRelativeWrapped(FileSys::VirtualDir base,
 VfsDirectoryServiceWrapper::VfsDirectoryServiceWrapper(FileSys::VirtualDir backing_)
     : backing(std::move(backing_)) {}
 
+VfsDirectoryServiceWrapper::~VfsDirectoryServiceWrapper() = default;
+
 std::string VfsDirectoryServiceWrapper::GetName() const {
     return backing->GetName();
 }
@@ -258,28 +261,15 @@ ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory) {
     return RESULT_SUCCESS;
 }
 
-ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() {
-    LOG_TRACE(Service_FS, "Opening RomFS for current process");
+ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id) {
+    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}", title_id);
 
     if (romfs_factory == nullptr) {
         // TODO(bunnei): Find a better error code for this
         return ResultCode(-1);
     }
 
-    return romfs_factory->OpenCurrentProcess();
-}
-
-ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
-                                          FileSys::ContentRecordType type) {
-    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}",
-              title_id, static_cast<u8>(storage_id), static_cast<u8>(type));
-
-    if (romfs_factory == nullptr) {
-        // TODO(bunnei): Find a better error code for this
-        return ResultCode(-1);
-    }
-
-    return romfs_factory->Open(title_id, storage_id, type);
+    return romfs_factory->Open(title_id);
 }
 
 ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,

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

@@ -7,6 +7,7 @@
 #include <memory>
 #include "common/common_types.h"
 #include "core/file_sys/directory.h"
+#include "core/file_sys/mode.h"
 #include "core/hle/result.h"
 
 namespace FileSys {
@@ -16,10 +17,7 @@ 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
@@ -37,9 +35,7 @@ ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory)
 ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory);
 ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
 
-ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess();
-ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
-                                          FileSys::ContentRecordType type);
+ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id);
 ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
                                             FileSys::SaveDataDescriptor save_struct);
 ResultVal<FileSys::VirtualDir> OpenSDMC();
@@ -56,6 +52,7 @@ void InstallInterfaces(SM::ServiceManager& service_manager, const FileSys::Virtu
 class VfsDirectoryServiceWrapper {
 public:
     explicit VfsDirectoryServiceWrapper(FileSys::VirtualDir backing);
+    ~VfsDirectoryServiceWrapper();
 
     /**
      * Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)

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

@@ -13,12 +13,10 @@
 #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"
@@ -26,6 +24,15 @@
 
 namespace Service::FileSystem {
 
+enum class StorageId : u8 {
+    None = 0,
+    Host = 1,
+    GameCard = 2,
+    NandSystem = 3,
+    NandUser = 4,
+    SdCard = 5,
+};
+
 class IStorage final : public ServiceFramework<IStorage> {
 public:
     explicit IStorage(FileSys::VirtualFile backend_)
@@ -461,7 +468,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {110, nullptr, "OpenContentStorageFileSystem"},
         {200, &FSP_SRV::OpenDataStorageByCurrentProcess, "OpenDataStorageByCurrentProcess"},
         {201, nullptr, "OpenDataStorageByProgramId"},
-        {202, &FSP_SRV::OpenDataStorageByDataId, "OpenDataStorageByDataId"},
+        {202, nullptr, "OpenDataStorageByDataId"},
         {203, &FSP_SRV::OpenRomStorage, "OpenRomStorage"},
         {400, nullptr, "OpenDeviceOperator"},
         {500, nullptr, "OpenSdCardDetectionEventNotifier"},
@@ -574,7 +581,7 @@ void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
-    auto romfs = OpenRomFSCurrentProcess();
+    auto romfs = OpenRomFS(Core::System::GetInstance().CurrentProcess()->program_id);
     if (romfs.Failed()) {
         // TODO (bunnei): Find the right error code to use here
         LOG_CRITICAL(Service_FS, "no file system interface available!");
@@ -590,37 +597,10 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<IStorage>(std::move(storage));
 }
 
-void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto storage_id = rp.PopRaw<FileSys::StorageId>();
-    const auto unknown = rp.PopRaw<u32>();
-    const auto title_id = rp.PopRaw<u64>();
-
-    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, unknown={:08X}, title_id={:016X}",
-              static_cast<u8>(storage_id), unknown, title_id);
-
-    auto data = OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
-    if (data.Failed()) {
-        // TODO(DarkLordZach): Find the right error code to use here
-        LOG_ERROR(Service_FS,
-                  "could not open data storage with title_id={:016X}, storage_id={:02X}", title_id,
-                  static_cast<u8>(storage_id));
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultCode(-1));
-        return;
-    }
-
-    IStorage storage(std::move(data.Unwrap()));
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IStorage>(std::move(storage));
-}
-
 void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
-    auto storage_id = rp.PopRaw<FileSys::StorageId>();
+    auto storage_id = rp.PopRaw<StorageId>();
     auto title_id = rp.PopRaw<u64>();
 
     LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}",

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

@@ -25,7 +25,6 @@ private:
     void MountSaveData(Kernel::HLERequestContext& ctx);
     void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
-    void OpenDataStorageByDataId(Kernel::HLERequestContext& ctx);
     void OpenRomStorage(Kernel::HLERequestContext& ctx);
 
     FileSys::VirtualFile romfs;

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

@@ -5,98 +5,31 @@
 #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 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);
-}
+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},
+};
 
 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"},
@@ -107,78 +40,26 @@ PL_U::PL_U() : ServiceFramework("pl:u") {
         {5, &PL_U::GetSharedFontInOrderOfPriority, "GetSharedFontInOrderOfPriority"},
     };
     RegisterHandlers(functions);
-    // Attempt to load shared font data from disk
-    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 {
-        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);
-        }
+    // 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());
+    } 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);
@@ -201,7 +82,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>(GetSharedFontRegion(font_id).size);
+    rb.Push<u32>(SHARED_FONT_REGIONS[font_id].size);
 }
 
 void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
@@ -211,10 +92,14 @@ 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>(GetSharedFontRegion(font_id).offset);
+    rb.Push<u32>(SHARED_FONT_REGIONS[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);
@@ -243,9 +128,8 @@ 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));
-        auto region = GetSharedFontRegion(i);
-        font_offsets.push_back(region.offset);
-        font_sizes.push_back(region.size);
+        font_offsets.push_back(SHARED_FONT_REGIONS[i].offset);
+        font_sizes.push_back(SHARED_FONT_REGIONS[i].size);
     }
 
     ctx.WriteBuffer(font_codes, 0);

src/core/perf_stats.cpp

@@ -76,31 +76,22 @@ 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 = 25000us;
+    constexpr microseconds MAX_LAG_TIME_US = 25us;
 
-    if (!Settings::values.use_frame_limit) {
+    if (!Settings::values.toggle_framelimit) {
         return;
     }
 
     auto now = Clock::now();
 
-    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 += current_system_time_us - previous_system_time_us;
     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,8 +130,7 @@ struct Values {
 
     // Renderer
     float resolution_factor;
-    bool use_frame_limit;
-    u16 frame_limit;
+    bool toggle_framelimit;
     bool use_accurate_framebuffers;
 
     float bg_red;

src/core/telemetry_session.cpp

@@ -2,16 +2,34 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "common/file_util.h"
+#include <cstring>
 
+#include "common/assert.h"
+#include "common/file_util.h"
+#include "common/scm_rev.h"
+#ifdef ARCHITECTURE_x86_64
+#include "common/x64/cpu_detect.h"
+#endif
 #include "core/core.h"
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 
 namespace Core {
 
+#ifdef ARCHITECTURE_x86_64
+static const char* CpuVendorToStr(Common::CPUVendor vendor) {
+    switch (vendor) {
+    case Common::CPUVendor::INTEL:
+        return "Intel";
+    case Common::CPUVendor::AMD:
+        return "Amd";
+    case Common::CPUVendor::OTHER:
+        return "Other";
+    }
+    UNREACHABLE();
+}
+#endif
+
 static u64 GenerateTelemetryId() {
     u64 telemetry_id{};
     return telemetry_id;
@@ -19,8 +37,8 @@ static u64 GenerateTelemetryId() {
 
 u64 GetTelemetryId() {
     u64 telemetry_id{};
-    const std::string filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
-                               "telemetry_id"};
+    static const std::string& filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
+                                       "telemetry_id"};
 
     if (FileUtil::Exists(filename)) {
         FileUtil::IOFile file(filename, "rb");
@@ -44,8 +62,8 @@ u64 GetTelemetryId() {
 
 u64 RegenerateTelemetryId() {
     const u64 new_telemetry_id{GenerateTelemetryId()};
-    const std::string filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
-                               "telemetry_id"};
+    static const std::string& filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
+                                       "telemetry_id"};
 
     FileUtil::IOFile file(filename, "wb");
     if (!file.IsOpen()) {
@@ -94,11 +112,48 @@ TelemetrySession::TelemetrySession() {
     }
 
     // Log application information
-    Telemetry::AppendBuildInfo(field_collection);
+    const bool is_git_dirty{std::strstr(Common::g_scm_desc, "dirty") != nullptr};
+    AddField(Telemetry::FieldType::App, "Git_IsDirty", is_git_dirty);
+    AddField(Telemetry::FieldType::App, "Git_Branch", Common::g_scm_branch);
+    AddField(Telemetry::FieldType::App, "Git_Revision", Common::g_scm_rev);
+    AddField(Telemetry::FieldType::App, "BuildDate", Common::g_build_date);
+    AddField(Telemetry::FieldType::App, "BuildName", Common::g_build_name);
 
-    // Log user system information
-    Telemetry::AppendCPUInfo(field_collection);
-    Telemetry::AppendOSInfo(field_collection);
+// Log user system information
+#ifdef ARCHITECTURE_x86_64
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Model", Common::GetCPUCaps().cpu_string);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_BrandString",
+             Common::GetCPUCaps().brand_string);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Vendor",
+             CpuVendorToStr(Common::GetCPUCaps().vendor));
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_AES", Common::GetCPUCaps().aes);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_AVX", Common::GetCPUCaps().avx);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_AVX2", Common::GetCPUCaps().avx2);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_BMI1", Common::GetCPUCaps().bmi1);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_BMI2", Common::GetCPUCaps().bmi2);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_FMA", Common::GetCPUCaps().fma);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_FMA4", Common::GetCPUCaps().fma4);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE", Common::GetCPUCaps().sse);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE2", Common::GetCPUCaps().sse2);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE3", Common::GetCPUCaps().sse3);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSSE3",
+             Common::GetCPUCaps().ssse3);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE41",
+             Common::GetCPUCaps().sse4_1);
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE42",
+             Common::GetCPUCaps().sse4_2);
+#else
+    AddField(Telemetry::FieldType::UserSystem, "CPU_Model", "Other");
+#endif
+#ifdef __APPLE__
+    AddField(Telemetry::FieldType::UserSystem, "OsPlatform", "Apple");
+#elif defined(_WIN32)
+    AddField(Telemetry::FieldType::UserSystem, "OsPlatform", "Windows");
+#elif defined(__linux__) || defined(linux) || defined(__linux)
+    AddField(Telemetry::FieldType::UserSystem, "OsPlatform", "Linux");
+#else
+    AddField(Telemetry::FieldType::UserSystem, "OsPlatform", "Unknown");
+#endif
 
     // Log user configuration information
     AddField(Telemetry::FieldType::UserConfig, "Core_UseCpuJit", Settings::values.use_cpu_jit);
@@ -106,9 +161,8 @@ TelemetrySession::TelemetrySession() {
              Settings::values.use_multi_core);
     AddField(Telemetry::FieldType::UserConfig, "Renderer_ResolutionFactor",
              Settings::values.resolution_factor);
-    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_ToggleFramelimit",
+             Settings::values.toggle_framelimit);
     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,36 +311,6 @@ 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,
@@ -519,16 +489,8 @@ public:
 
                 float clear_color[4];
                 float clear_depth;
-                INSERT_PADDING_WORDS(0x3);
-                s32 clear_stencil;
 
-                INSERT_PADDING_WORDS(0x6C);
-
-                s32 stencil_back_func_ref;
-                u32 stencil_back_mask;
-                u32 stencil_back_func_mask;
-
-                INSERT_PADDING_WORDS(0x20);
+                INSERT_PADDING_WORDS(0x93);
 
                 struct {
                     u32 address_high;
@@ -592,14 +554,16 @@ public:
                     u32 enable[NumRenderTargets];
                 } blend;
 
-                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;
+                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;
 
                 INSERT_PADDING_WORDS(0x3);
 
@@ -643,11 +607,13 @@ public:
 
                 INSERT_PADDING_WORDS(0x5);
 
-                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;
+                struct {
+                    u32 enable;
+                    u32 back_op_fail;
+                    u32 back_op_zfail;
+                    u32 back_op_zpass;
+                    u32 back_func_func;
+                } stencil_two_side;
 
                 INSERT_PADDING_WORDS(0x17);
 
@@ -729,14 +695,7 @@ public:
 
                 Cull cull;
 
-                INSERT_PADDING_WORDS(0x28);
-
-                struct {
-                    u32 enable;
-                    LogicOperation operation;
-                } logic_op;
-
-                INSERT_PADDING_WORDS(0x1);
+                INSERT_PADDING_WORDS(0x2B);
 
                 union {
                     u32 raw;
@@ -959,10 +918,6 @@ 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);
@@ -974,31 +929,19 @@ 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_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(stencil, 0x4E0);
 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_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(stencil_two_side, 0x565);
 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,19 +280,6 @@ 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;
@@ -490,9 +477,7 @@ union Instruction {
             if (texture_info >= 12 && texture_info <= 13)
                 return TextureType::TextureCube;
 
-            LOG_CRITICAL(HW_GPU, "Unhandled texture_info: {}",
-                         static_cast<u32>(texture_info.Value()));
-            UNREACHABLE();
+            UNIMPLEMENTED();
         }
 
         bool IsArrayTexture() const {
@@ -531,16 +516,14 @@ 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) {
                 return TextureType::Texture3D;
             }
 
-            LOG_CRITICAL(HW_GPU, "Unhandled texture_info: {}",
-                         static_cast<u32>(texture_info.Value()));
-            UNREACHABLE();
+            UNIMPLEMENTED();
         }
 
         bool IsArrayTexture() const {
@@ -663,9 +646,6 @@ public:
         LOP_R,
         LOP_IMM,
         LOP32I,
-        LOP3_C,
-        LOP3_R,
-        LOP3_IMM,
         MOV_C,
         MOV_R,
         MOV_IMM,
@@ -888,9 +868,6 @@ 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,6 +8,8 @@
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
 
+struct ScreenInfo;
+
 namespace VideoCore {
 
 class RasterizerInterface {
@@ -53,7 +55,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) {
+                                   u32 pixel_stride, ScreenInfo& screen_info) {
         return false;
     }
 

src/video_core/renderer_base.cpp

@@ -2,6 +2,7 @@
 // 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"
@@ -16,9 +17,16 @@ RendererBase::RendererBase(Core::Frontend::EmuWindow& window) : render_window{wi
 RendererBase::~RendererBase() = default;
 
 void RendererBase::RefreshBaseSettings() {
+    RefreshRasterizerSetting();
     UpdateCurrentFramebufferLayout();
 
-    renderer_settings.use_framelimiter = Settings::values.use_frame_limit;
+    renderer_settings.use_framelimiter = Settings::values.toggle_framelimit;
+}
+
+void RendererBase::RefreshRasterizerSetting() {
+    if (rasterizer == nullptr) {
+        rasterizer = std::make_unique<RasterizerOpenGL>(render_window);
+    }
 }
 
 void RendererBase::UpdateCurrentFramebufferLayout() {

src/video_core/renderer_base.h

@@ -58,6 +58,9 @@ 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,7 +14,6 @@
 #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"
@@ -26,8 +25,6 @@
 #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;
@@ -39,8 +36,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, ScreenInfo& info)
-    : emu_window{window}, screen_info{info}, stream_buffer(GL_ARRAY_BUFFER, STREAM_BUFFER_SIZE) {
+RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window)
+    : emu_window{window}, 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();
@@ -182,7 +179,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::MAX_PROGRAM_CODE_LENGTH);
+    GLShader::ProgramCode program_code;
     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)};
@@ -307,8 +304,7 @@ bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
 }
 
 std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb,
-                                                                    bool using_depth_fb,
-                                                                    bool preserve_contents) {
+                                                                    bool using_depth_fb) {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 
     if (regs.rt[0].format == Tegra::RenderTargetFormat::NONE) {
@@ -316,20 +312,22 @@ std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_c
         using_color_fb = false;
     }
 
-    const bool has_stencil = regs.stencil_enable;
+    // TODO(bunnei): Implement this
+    const bool has_stencil = false;
+
     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.front.write_mask || state.stencil.back.write_mask));
+        (has_stencil && state.stencil.test_enabled && state.stencil.write_mask != 0);
 
     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, preserve_contents);
+        res_cache.GetFramebufferSurfaces(using_color_fb, using_depth_fb);
 
     const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[0].GetRect()};
     const MathUtil::Rectangle<u32> draw_rect{
@@ -363,70 +361,41 @@ std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_c
 }
 
 void RasterizerOpenGL::Clear() {
-    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;
 
-    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 ||
+    GLbitfield clear_mask = 0;
+    if (regs.clear_buffers.R && regs.clear_buffers.G && regs.clear_buffers.B &&
         regs.clear_buffers.A) {
-        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);
-        }
+        clear_mask |= GL_COLOR_BUFFER_BIT;
+        use_color_fb = true;
     }
     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.
-        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;
+        state.depth.test_enabled = true;
+        state.depth.write_mask = GL_TRUE;
+        state.depth.test_func = GL_ALWAYS;
+        state.Apply();
     }
 
-    if (!use_color_fb && !use_depth_fb) {
-        // No color surface nor depth/stencil surface are enabled
+    if (clear_mask == 0)
         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, false);
-
-    clear_state.Apply();
+        ConfigureFramebuffers(use_color_fb, use_depth_fb);
 
+    // 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);
 
@@ -476,12 +445,10 @@ 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, true);
+        ConfigureFramebuffers(true, regs.zeta.Address() != 0 && regs.zeta_enable != 0);
 
     SyncDepthTestState();
-    SyncStencilTestState();
     SyncBlendState();
-    SyncLogicOpState();
     SyncCullMode();
 
     // TODO(bunnei): Sync framebuffer_scale uniform here
@@ -607,7 +574,8 @@ bool RasterizerOpenGL::AccelerateFill(const void* config) {
 }
 
 bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
-                                         VAddr framebuffer_addr, u32 pixel_stride) {
+                                         VAddr framebuffer_addr, u32 pixel_stride,
+                                         ScreenInfo& screen_info) {
     if (!framebuffer_addr) {
         return {};
     }
@@ -870,34 +838,6 @@ 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;
 
@@ -907,9 +847,6 @@ 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);
@@ -919,19 +856,3 @@ 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,17 +22,15 @@
 #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, ScreenInfo& info);
+    explicit RasterizerOpenGL(Core::Frontend::EmuWindow& renderer);
     ~RasterizerOpenGL() override;
 
     void DrawArrays() override;
@@ -45,8 +43,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& config, VAddr framebuffer_addr,
-                           u32 pixel_stride) override;
+    bool AccelerateDisplay(const Tegra::FramebufferConfig& framebuffer, VAddr framebuffer_addr,
+                           u32 pixel_stride, ScreenInfo& screen_info) override;
     bool AccelerateDrawBatch(bool is_indexed) override;
 
     /// OpenGL shader generated for a given Maxwell register state
@@ -89,8 +87,7 @@ 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,
-                                                      bool preserve_contents);
+    std::pair<Surface, Surface> ConfigureFramebuffers(bool using_color_fb, bool using_depth_fb);
 
     /// Binds the framebuffer color and depth surface
     void BindFramebufferSurfaces(const Surface& color_surface, const Surface& depth_surface,
@@ -141,15 +138,9 @@ 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;
@@ -160,8 +151,6 @@ private:
 
     Core::Frontend::EmuWindow& emu_window;
 
-    ScreenInfo& screen_info;
-
     std::unique_ptr<GLShader::ProgramManager> shader_program_manager;
     OGLVertexArray sw_vao;
     OGLVertexArray hw_vao;
@@ -189,5 +178,3 @@ private:
     enum class AccelDraw { Disabled, Arrays, Indexed };
     AccelDraw accelerate_draw = AccelDraw::Disabled;
 };
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -19,8 +19,6 @@
 #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;
@@ -688,8 +686,7 @@ Surface RasterizerCacheOpenGL::GetTextureSurface(const Tegra::Texture::FullTextu
 }
 
 SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool using_color_fb,
-                                                                       bool using_depth_fb,
-                                                                       bool preserve_contents) {
+                                                                       bool using_depth_fb) {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 
     // TODO(bunnei): This is hard corded to use just the first render buffer
@@ -711,7 +708,7 @@ SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool usin
     MathUtil::Rectangle<u32> color_rect{};
     Surface color_surface;
     if (using_color_fb) {
-        color_surface = GetSurface(color_params, preserve_contents);
+        color_surface = GetSurface(color_params);
         if (color_surface) {
             color_rect = color_surface->GetSurfaceParams().GetRect();
         }
@@ -720,7 +717,7 @@ SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool usin
     MathUtil::Rectangle<u32> depth_rect{};
     Surface depth_surface;
     if (using_depth_fb) {
-        depth_surface = GetSurface(depth_params, preserve_contents);
+        depth_surface = GetSurface(depth_params);
         if (depth_surface) {
             depth_rect = depth_surface->GetSurfaceParams().GetRect();
         }
@@ -755,7 +752,7 @@ void RasterizerCacheOpenGL::FlushSurface(const Surface& surface) {
     surface->FlushGLBuffer();
 }
 
-Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool preserve_contents) {
+Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params) {
     if (params.addr == 0 || params.height * params.width == 0) {
         return {};
     }
@@ -777,33 +774,16 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool pres
         } else if (surface->GetSurfaceParams().IsCompatibleSurface(params)) {
             // Use the cached surface as-is
             return surface;
-        } else if (preserve_contents) {
-            // If surface parameters changed and we care about keeping the previous data, recreate
-            // the surface from the old one
-            UnregisterSurface(surface);
-            Surface new_surface{RecreateSurface(surface, params)};
-            RegisterSurface(new_surface);
-            return new_surface;
         } else {
-            // Delete the old surface before creating a new one to prevent collisions.
-            UnregisterSurface(surface);
+            // If surface parameters changed, recreate the surface from the old one
+            return RecreateSurface(surface, params);
         }
     }
 
-    // Try to get a previously reserved surface
-    surface = TryGetReservedSurface(params);
-
     // No surface found - create a new one
-    if (!surface) {
-        surface = std::make_shared<CachedSurface>(params);
-        ReserveSurface(surface);
-        RegisterSurface(surface);
-    }
-
-    // Only load surface from memory if we care about the contents
-    if (preserve_contents) {
-        LoadSurface(surface);
-    }
+    surface = std::make_shared<CachedSurface>(params);
+    RegisterSurface(surface);
+    LoadSurface(surface);
 
     return surface;
 }
@@ -812,76 +792,17 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& surface,
                                                const SurfaceParams& new_params) {
     // Verify surface is compatible for blitting
     const auto& params{surface->GetSurfaceParams()};
+    ASSERT(params.type == new_params.type);
 
     // 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);
 
-    // If format is unchanged, we can do a faster blit without reinterpreting pixel data
-    if (params.pixel_format == new_params.pixel_format) {
-        BlitTextures(surface->Texture().handle, params.GetRect(), new_surface->Texture().handle,
-                     new_surface->GetSurfaceParams().GetRect(), params.type,
-                     read_framebuffer.handle, draw_framebuffer.handle);
-        return new_surface;
-    }
-
-    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);
-    if (source_format.compressed) {
-        glGetCompressedTextureImage(surface->Texture().handle, 0,
-                                    static_cast<GLsizei>(params.SizeInBytes()), nullptr);
-    } else {
-        glGetTextureImage(surface->Texture().handle, 0, source_format.format, source_format.type,
-                          static_cast<GLsizei>(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);
-    if (dest_format.compressed) {
-        glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
-                                  static_cast<GLsizei>(dest_rect.GetWidth()),
-                                  static_cast<GLsizei>(dest_rect.GetHeight()), dest_format.format,
-                                  static_cast<GLsizei>(new_params.SizeInBytes()), nullptr);
-    } else {
-        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);
+    RegisterSurface(new_surface);
 
     return new_surface;
 }
@@ -957,21 +878,6 @@ void RasterizerCacheOpenGL::UnregisterSurface(const Surface& surface) {
     surface_cache.erase(search);
 }
 
-void RasterizerCacheOpenGL::ReserveSurface(const Surface& surface) {
-    const auto& surface_reserve_key{SurfaceReserveKey::Create(surface->GetSurfaceParams())};
-    surface_reserve[surface_reserve_key] = surface;
-}
-
-Surface RasterizerCacheOpenGL::TryGetReservedSurface(const SurfaceParams& params) {
-    const auto& surface_reserve_key{SurfaceReserveKey::Create(params)};
-    auto search{surface_reserve.find(surface_reserve_key)};
-    if (search != surface_reserve.end()) {
-        RegisterSurface(search->second);
-        return search->second;
-    }
-    return {};
-}
-
 template <typename Map, typename Interval>
 constexpr auto RangeFromInterval(Map& map, const Interval& interval) {
     return boost::make_iterator_range(map.equal_range(interval));
@@ -1010,5 +916,3 @@ 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

@@ -11,14 +11,11 @@
 #include <boost/icl/interval_map.hpp>
 
 #include "common/common_types.h"
-#include "common/hash.h"
 #include "common/math_util.h"
 #include "video_core/engines/maxwell_3d.h"
 #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>>;
@@ -683,27 +680,6 @@ struct SurfaceParams {
     u32 cache_height;
 };
 
-}; // namespace OpenGL
-
-/// Hashable variation of SurfaceParams, used for a key in the surface cache
-struct SurfaceReserveKey : Common::HashableStruct<OpenGL::SurfaceParams> {
-    static SurfaceReserveKey Create(const OpenGL::SurfaceParams& params) {
-        SurfaceReserveKey res;
-        res.state = params;
-        return res;
-    }
-};
-namespace std {
-template <>
-struct hash<SurfaceReserveKey> {
-    size_t operator()(const SurfaceReserveKey& k) const {
-        return k.Hash();
-    }
-};
-} // namespace std
-
-namespace OpenGL {
-
 class CachedSurface final {
 public:
     CachedSurface(const SurfaceParams& params);
@@ -746,8 +722,7 @@ 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,
-                                                    bool preserve_contents);
+    SurfaceSurfaceRect_Tuple GetFramebufferSurfaces(bool using_color_fb, bool using_depth_fb);
 
     /// Flushes the surface to Switch memory
     void FlushSurface(const Surface& surface);
@@ -763,7 +738,7 @@ public:
 
 private:
     void LoadSurface(const Surface& surface);
-    Surface GetSurface(const SurfaceParams& params, bool preserve_contents = true);
+    Surface GetSurface(const SurfaceParams& params);
 
     /// Recreates a surface with new parameters
     Surface RecreateSurface(const Surface& surface, const SurfaceParams& new_params);
@@ -774,25 +749,12 @@ private:
     /// Remove surface from the cache
     void UnregisterSurface(const Surface& surface);
 
-    /// Reserves a unique surface that can be reused later
-    void ReserveSurface(const Surface& surface);
-
-    /// Tries to get a reserved surface for the specified parameters
-    Surface TryGetReservedSurface(const SurfaceParams& params);
-
     /// Increase/decrease the number of surface in pages touching the specified region
     void UpdatePagesCachedCount(Tegra::GPUVAddr addr, u64 size, int delta);
 
     std::unordered_map<Tegra::GPUVAddr, Surface> surface_cache;
     PageMap cached_pages;
 
-    /// The surface reserve is a "backup" cache, this is where we put unique surfaces that have
-    /// previously been used. This is to prevent surfaces from being constantly created and
-    /// destroyed when used with different surface parameters.
-    std::unordered_map<SurfaceReserveKey, Surface> surface_reserve;
-
     OGLFramebuffer read_framebuffer;
     OGLFramebuffer draw_framebuffer;
 };
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_resource_manager.h

@@ -10,8 +10,6 @@
 #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;
@@ -333,5 +331,3 @@ 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 OpenGL::GLShader::Decompiler {
+namespace GLShader::Decompiler {
 
 using Tegra::Shader::Attribute;
 using Tegra::Shader::Instruction;
@@ -26,7 +26,6 @@ using Tegra::Shader::Sampler;
 using Tegra::Shader::SubOp;
 
 constexpr u32 PROGRAM_END = MAX_PROGRAM_CODE_LENGTH;
-constexpr u32 PROGRAM_HEADER_SIZE = 0x50;
 
 class DecompileFail : public std::runtime_error {
 public:
@@ -440,13 +439,12 @@ public:
         }
         declarations.AddNewLine();
 
-        // 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();
+        const auto& samplers = GetSamplers();
+        for (const auto& sampler : samplers) {
+            declarations.AddLine("uniform " + sampler.GetTypeString() + ' ' + sampler.GetName() +
+                                 ';');
         }
+        declarations.AddNewLine();
     }
 
     /// Returns a list of constant buffer declarations
@@ -458,13 +456,14 @@ public:
     }
 
     /// Returns a list of samplers used in the shader
-    std::vector<SamplerEntry> GetSamplers() const {
+    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) {
+    std::string AccessSampler(const Sampler& sampler, Tegra::Shader::TextureType type,
+                              bool is_array) {
         size_t offset = static_cast<size_t>(sampler.index.Value());
 
         // If this sampler has already been used, return the existing mapping.
@@ -473,12 +472,13 @@ 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};
+        SamplerEntry entry{stage, offset, next_index, type, is_array};
         used_samplers.emplace_back(entry);
         return entry.GetName();
     }
@@ -621,23 +621,6 @@ public:
     }
 
 private:
-    // Shader program header for a Fragment Shader.
-    struct FragmentHeader {
-        INSERT_PADDING_WORDS(5);
-        INSERT_PADDING_WORDS(13);
-        u32 enabled_color_outputs;
-        union {
-            BitField<0, 1, u32> writes_samplemask;
-            BitField<1, 1, u32> writes_depth;
-        };
-
-        bool IsColorComponentOutputEnabled(u32 render_target, u32 component) const {
-            u32 bit = render_target * 4 + component;
-            return enabled_color_outputs & (1 << bit);
-        }
-    };
-    static_assert(sizeof(FragmentHeader) == PROGRAM_HEADER_SIZE, "FragmentHeader size is wrong");
-
     /// Gets the Subroutine object corresponding to the specified address.
     const Subroutine& GetSubroutine(u32 begin, u32 end) const {
         auto iter = subroutines.find(Subroutine{begin, end, suffix});
@@ -656,8 +639,8 @@ private:
     }
 
     /// Generates code representing a texture sampler.
-    std::string GetSampler(const Sampler& sampler) {
-        return regs.AccessSampler(sampler);
+    std::string GetSampler(const Sampler& sampler, Tegra::Shader::TextureType type, bool is_array) {
+        return regs.AccessSampler(sampler, type, is_array);
     }
 
     /**
@@ -849,33 +832,6 @@ 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
@@ -938,36 +894,6 @@ private:
         shader.AddLine('}');
     }
 
-    /// Writes the output values from a fragment shader to the corresponding GLSL output variables.
-    void EmitFragmentOutputsWrite() {
-        ASSERT(stage == Maxwell3D::Regs::ShaderStage::Fragment);
-        FragmentHeader header;
-        std::memcpy(&header, program_code.data(), PROGRAM_HEADER_SIZE);
-
-        ASSERT_MSG(header.writes_samplemask == 0, "Samplemask write is unimplemented");
-
-        // Write the color outputs using the data in the shader registers, disabled
-        // rendertargets/components are skipped in the register assignment.
-        u32 current_reg = 0;
-        for (u32 render_target = 0; render_target < Maxwell3D::Regs::NumRenderTargets;
-             ++render_target) {
-            // TODO(Subv): Figure out how dual-source blending is configured in the Switch.
-            for (u32 component = 0; component < 4; ++component) {
-                if (header.IsColorComponentOutputEnabled(render_target, component)) {
-                    shader.AddLine(fmt::format("color[{}][{}] = {};", render_target, component,
-                                               regs.GetRegisterAsFloat(current_reg)));
-                    ++current_reg;
-                }
-            }
-        }
-
-        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) + ';');
-        }
-    }
-
     /**
      * Compiles a single instruction from Tegra to GLSL.
      * @param offset the offset of the Tegra shader instruction.
@@ -1324,20 +1250,6 @@ 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: {
@@ -1596,10 +1508,29 @@ private:
                 break;
             }
             case OpCode::Id::TEX: {
-                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 + ");";
+                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.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.gpr8.Value() + 1);
+                    std::string z = regs.GetRegisterAsFloat(instr.gpr20);
+                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                    break;
+                }
+                default:
+                    UNIMPLEMENTED();
+                }
+
+                const std::string sampler =
+                    GetSampler(instr.sampler, instr.tex.texture_type, instr.tex.array);
                 // 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("{");
@@ -1621,20 +1552,60 @@ private:
                 break;
             }
             case OpCode::Id::TEXS: {
-                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 + ");";
+                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::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:
+                    UNIMPLEMENTED();
+                }
+                const std::string sampler = GetSampler(instr.sampler, instr.texs.GetTextureType(),
+                                                       instr.texs.IsArrayTexture());
 
                 const std::string texture = "texture(" + sampler + ", coords)";
                 WriteTexsInstruction(instr, coord, texture);
                 break;
             }
             case OpCode::Id::TLDS: {
-                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 + ");";
+                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()) {
+                        UNIMPLEMENTED();
+                    } else {
+                        std::string x = regs.GetRegisterAsInteger(instr.gpr8);
+                        std::string y = regs.GetRegisterAsInteger(instr.gpr20);
+                        coord = "ivec2 coords = ivec2(" + x + ", " + y + ");";
+                    }
+                    break;
+                }
+                default:
+                    UNIMPLEMENTED();
+                }
+                const std::string sampler = GetSampler(instr.sampler, instr.tlds.GetTextureType(),
+                                                       instr.tlds.IsArrayTexture());
                 const std::string texture = "texelFetch(" + sampler + ", coords, 0)";
                 WriteTexsInstruction(instr, coord, texture);
                 break;
@@ -1652,12 +1623,11 @@ private:
                     break;
                 }
                 default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
-                                 static_cast<u32>(instr.tld4.texture_type.Value()));
-                    UNREACHABLE();
+                    UNIMPLEMENTED();
                 }
 
-                const std::string sampler = GetSampler(instr.sampler);
+                const std::string sampler =
+                    GetSampler(instr.sampler, instr.tld4.texture_type, instr.tld4.array);
                 // 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("{");
@@ -1683,7 +1653,8 @@ 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);
+                const std::string sampler =
+                    GetSampler(instr.sampler, Tegra::Shader::TextureType::Texture2D, false);
                 const std::string coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
                 const std::string texture = "textureGather(" + sampler + ", coords, " +
                                             std::to_string(instr.tld4s.component) + ')';
@@ -1989,8 +1960,12 @@ private:
         default: {
             switch (opcode->GetId()) {
             case OpCode::Id::EXIT: {
+                // Final color output is currently hardcoded to GPR0-3 for fragment shaders
                 if (stage == Maxwell3D::Regs::ShaderStage::Fragment) {
-                    EmitFragmentOutputsWrite();
+                    shader.AddLine("color.r = " + regs.GetRegisterAsFloat(0) + ';');
+                    shader.AddLine("color.g = " + regs.GetRegisterAsFloat(1) + ';');
+                    shader.AddLine("color.b = " + regs.GetRegisterAsFloat(2) + ';');
+                    shader.AddLine("color.a = " + regs.GetRegisterAsFloat(3) + ';');
                 }
 
                 switch (instr.flow.cond) {
@@ -2217,4 +2192,4 @@ boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code,
     return boost::none;
 }
 
-} // namespace OpenGL::GLShader::Decompiler
+} // namespace 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 OpenGL::GLShader::Decompiler {
+namespace 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 OpenGL::GLShader::Decompiler
+} // namespace 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 OpenGL::GLShader {
+namespace GLShader {
 
 using Tegra::Engines::Maxwell3D;
 
@@ -87,7 +87,7 @@ ProgramResult GenerateFragmentShader(const ShaderSetup& setup, const MaxwellFSCo
             .get_value_or({});
     out += R"(
 in vec4 position;
-layout(location = 0) out vec4 color[8];
+out vec4 color;
 
 layout (std140) uniform fs_config {
     vec4 viewport_flip;
@@ -103,4 +103,4 @@ void main() {
     return {out, program.second};
 }
 
-} // namespace OpenGL::GLShader
+} // namespace GLShader

src/video_core/renderer_opengl/gl_shader_gen.h

@@ -9,14 +9,15 @@
 #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 OpenGL::GLShader {
+namespace GLShader {
 
 constexpr size_t MAX_PROGRAM_CODE_LENGTH{0x1000};
-using ProgramCode = std::vector<u64>;
+
+using ProgramCode = std::array<u64, MAX_PROGRAM_CODE_LENGTH>;
 
 class ConstBufferEntry {
     using Maxwell = Tegra::Engines::Maxwell3D::Regs;
@@ -72,8 +73,9 @@ class SamplerEntry {
     using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 
 public:
-    SamplerEntry(Maxwell::ShaderStage stage, size_t offset, size_t index)
-        : offset(offset), stage(stage), sampler_index(index) {}
+    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) {}
 
     size_t GetOffset() const {
         return offset;
@@ -88,8 +90,41 @@ public:
     }
 
     std::string GetName() const {
-        return std::string(TextureSamplerNames[static_cast<size_t>(stage)]) + '[' +
-               std::to_string(sampler_index) + ']';
+        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;
     }
 
     static std::string GetArrayName(Maxwell::ShaderStage stage) {
@@ -100,11 +135,14 @@ 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.
+    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.
 };
 
 struct ShaderEntries {
@@ -115,8 +153,8 @@ struct ShaderEntries {
 using ProgramResult = std::pair<std::string, ShaderEntries>;
 
 struct ShaderSetup {
-    explicit ShaderSetup(ProgramCode program_code) {
-        program.code = std::move(program_code);
+    ShaderSetup(const ProgramCode& program_code) {
+        program.code = program_code;
     }
 
     struct {
@@ -135,8 +173,8 @@ struct ShaderSetup {
     }
 
     /// Used in scenarios where we have a dual vertex shaders
-    void SetProgramB(ProgramCode program_b) {
-        program.code_b = std::move(program_b);
+    void SetProgramB(const ProgramCode& program_b) {
+        program.code_b = program_b;
         has_program_b = true;
     }
 
@@ -146,18 +184,13 @@ 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
-            const u64 hash_b = Common::ComputeHash64(program.code_b.data(), program.code_b.size());
-            boost::hash_combine(hash, hash_b);
+            return Common::ComputeHash64(&program, sizeof(program));
+        } else {
+            // Compute hash over a single shader program
+            return Common::ComputeHash64(&program.code, program.code.size());
         }
-
-        return hash;
     }
 
     u64 program_code_hash{};
@@ -196,20 +229,20 @@ ProgramResult GenerateVertexShader(const ShaderSetup& setup, const MaxwellVSConf
  */
 ProgramResult GenerateFragmentShader(const ShaderSetup& setup, const MaxwellFSConfig& config);
 
-} // namespace OpenGL::GLShader
+} // namespace GLShader
 
 namespace std {
 
 template <>
-struct hash<OpenGL::GLShader::MaxwellVSConfig> {
-    size_t operator()(const OpenGL::GLShader::MaxwellVSConfig& k) const {
+struct hash<GLShader::MaxwellVSConfig> {
+    size_t operator()(const GLShader::MaxwellVSConfig& k) const {
         return k.Hash();
     }
 };
 
 template <>
-struct hash<OpenGL::GLShader::MaxwellFSConfig> {
-    size_t operator()(const OpenGL::GLShader::MaxwellFSConfig& k) const {
+struct hash<GLShader::MaxwellFSConfig> {
+    size_t operator()(const 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 OpenGL::GLShader {
+namespace 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 OpenGL::GLShader
+} // namespace 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 OpenGL::GLShader {
+namespace 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 OpenGL::GLShader
+} // namespace 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 OpenGL::GLShader {
+namespace 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 OpenGL::GLShader
+} // namespace GLShader

src/video_core/renderer_opengl/gl_shader_util.h

@@ -10,7 +10,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 
-namespace OpenGL::GLShader {
+namespace 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 OpenGL::GLShader
+} // namespace GLShader

src/video_core/renderer_opengl/gl_state.cpp

@@ -7,8 +7,6 @@
 #include "common/logging/log.h"
 #include "video_core/renderer_opengl/gl_state.h"
 
-namespace OpenGL {
-
 OpenGLState OpenGLState::cur_state;
 
 OpenGLState::OpenGLState() {
@@ -27,17 +25,13 @@ OpenGLState::OpenGLState() {
     color_mask.alpha_enabled = GL_TRUE;
 
     stencil.test_enabled = false;
-    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);
+    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;
 
     blend.enabled = true;
     blend.rgb_equation = GL_FUNC_ADD;
@@ -51,8 +45,7 @@ OpenGLState::OpenGLState() {
     blend.color.blue = 0.0f;
     blend.color.alpha = 0.0f;
 
-    logic_op.enabled = false;
-    logic_op.operation = GL_COPY;
+    logic_op = GL_COPY;
 
     for (auto& texture_unit : texture_units) {
         texture_unit.Reset();
@@ -133,31 +126,33 @@ void OpenGLState::Apply() const {
             glDisable(GL_STENCIL_TEST);
         }
     }
-    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);
+
+    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);
+    }
 
     // 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);
         }
     }
 
@@ -181,18 +176,8 @@ void OpenGLState::Apply() const {
         glBlendEquationSeparate(blend.rgb_equation, blend.a_equation);
     }
 
-    // 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);
+    if (logic_op != cur_state.logic_op) {
+        glLogicOp(logic_op);
     }
 
     // Textures
@@ -343,5 +328,3 @@ OpenGLState& OpenGLState::ResetFramebuffer(GLuint handle) {
     }
     return *this;
 }
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_state.h

@@ -9,8 +9,6 @@
 
 #include "video_core/engines/maxwell_3d.h"
 
-namespace OpenGL {
-
 using Regs = Tegra::Engines::Maxwell3D::Regs;
 
 namespace TextureUnits {
@@ -58,16 +56,14 @@ public:
     } color_mask; // GL_COLOR_WRITEMASK
 
     struct {
-        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;
+        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
     } stencil;
 
     struct {
@@ -87,10 +83,7 @@ public:
         } color; // GL_BLEND_COLOR
     } blend;
 
-    struct {
-        bool enabled; // GL_LOGIC_OP_MODE
-        GLenum operation;
-    } logic_op;
+    GLenum logic_op; // GL_LOGIC_OP_MODE
 
     // 3 texture units - one for each that is used in PICA fragment shader emulation
     struct TextureUnit {
@@ -167,5 +160,3 @@ public:
 private:
     static OpenGLState cur_state;
 };
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_stream_buffer.cpp

@@ -9,8 +9,6 @@
 #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();
@@ -99,5 +97,3 @@ void OGLStreamBuffer::Unmap(GLsizeiptr size) {
 
     buffer_pos += size;
 }
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_stream_buffer.h

@@ -2,15 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#pragma once
-
 #include <tuple>
 #include <glad/glad.h>
 #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);
@@ -44,5 +40,3 @@ private:
     GLsizeiptr mapped_size = 0;
     u8* mapped_ptr = nullptr;
 };
-
-} // namespace OpenGL

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -10,8 +10,6 @@
 #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>;
@@ -109,8 +107,6 @@ 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:
@@ -295,30 +291,6 @@ 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:
@@ -345,45 +317,4 @@ 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,12 +16,9 @@
 #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
 
@@ -133,7 +130,7 @@ void RendererOpenGL::SwapBuffers(boost::optional<const Tegra::FramebufferConfig&
         }
 
         // Load the framebuffer from memory, draw it to the screen, and swap buffers
-        LoadFBToScreenInfo(*framebuffer);
+        LoadFBToScreenInfo(*framebuffer, screen_info);
         DrawScreen();
         render_window.SwapBuffers();
     }
@@ -145,12 +142,14 @@ 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) {
+void RendererOpenGL::LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer,
+                                        ScreenInfo& screen_info) {
     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};
@@ -163,7 +162,8 @@ 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)) {
+    if (!rasterizer->AccelerateDisplay(framebuffer, framebuffer_addr, framebuffer.stride,
+                                       screen_info)) {
         // Reset the screen info's display texture to its own permanent texture
         screen_info.display_texture = screen_info.texture.resource.handle;
 
@@ -276,14 +276,6 @@ 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) {
 
@@ -440,7 +432,7 @@ static void APIENTRY DebugHandler(GLenum source, GLenum type, GLuint id, GLenum
         break;
     case GL_DEBUG_SEVERITY_NOTIFICATION:
     case GL_DEBUG_SEVERITY_LOW:
-        LOG_DEBUG(Render_OpenGL, format, str_source, str_type, id, message);
+        LOG_TRACE(Render_OpenGL, format, str_source, str_type, id, message);
         break;
     }
 }
@@ -471,12 +463,11 @@ bool RendererOpenGL::Init() {
     }
 
     InitOpenGLObjects();
-    CreateRasterizer();
+
+    RefreshRasterizerSetting();
 
     return true;
 }
 
 /// Shutdown the renderer
 void RendererOpenGL::ShutDown() {}
-
-} // namespace OpenGL

src/video_core/renderer_opengl/renderer_opengl.h

@@ -16,8 +16,6 @@ namespace Core::Frontend {
 class EmuWindow;
 }
 
-namespace OpenGL {
-
 /// Structure used for storing information about the textures for the Switch screen
 struct TextureInfo {
     OGLTexture resource;
@@ -61,8 +59,6 @@ public:
 
 private:
     void InitOpenGLObjects();
-    void CreateRasterizer();
-
     void ConfigureFramebufferTexture(TextureInfo& texture,
                                      const Tegra::FramebufferConfig& framebuffer);
     void DrawScreen();
@@ -70,7 +66,7 @@ private:
     void UpdateFramerate();
 
     // Loads framebuffer from emulated memory into the display information structure
-    void LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer);
+    void LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer, ScreenInfo& screen_info);
     // 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);
@@ -100,5 +96,3 @@ 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<OpenGL::RendererOpenGL>(emu_window);
+    return std::make_unique<RendererOpenGL>(emu_window);
 }
 
 } // namespace VideoCore

src/yuzu/configuration/config.cpp

@@ -83,8 +83,7 @@ void Config::ReadValues() {
 
     qt_config->beginGroup("Renderer");
     Settings::values.resolution_factor = qt_config->value("resolution_factor", 1.0).toFloat();
-    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.toggle_framelimit = qt_config->value("toggle_framelimit", true).toBool();
     Settings::values.use_accurate_framebuffers =
         qt_config->value("use_accurate_framebuffers", false).toBool();
 
@@ -125,7 +124,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", 64).toUInt();
+    UISettings::values.icon_size = qt_config->value("icon_size", 48).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();
@@ -204,8 +203,7 @@ void Config::SaveValues() {
 
     qt_config->beginGroup("Renderer");
     qt_config->setValue("resolution_factor", (double)Settings::values.resolution_factor);
-    qt_config->setValue("use_frame_limit", Settings::values.use_frame_limit);
-    qt_config->setValue("frame_limit", Settings::values.frame_limit);
+    qt_config->setValue("toggle_framelimit", Settings::values.toggle_framelimit);
     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,10 +12,6 @@ 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;
@@ -62,15 +58,13 @@ Resolution FromResolutionFactor(float factor) {
 void ConfigureGraphics::setConfiguration() {
     ui->resolution_factor_combobox->setCurrentIndex(
         static_cast<int>(FromResolutionFactor(Settings::values.resolution_factor)));
-    ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit);
-    ui->frame_limit->setValue(Settings::values.frame_limit);
+    ui->toggle_framelimit->setChecked(Settings::values.toggle_framelimit);
     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.use_frame_limit = ui->toggle_frame_limit->isChecked();
-    Settings::values.frame_limit = ui->frame_limit->value();
+    Settings::values.toggle_framelimit = ui->toggle_framelimit->isChecked();
     Settings::values.use_accurate_framebuffers = ui->use_accurate_framebuffers->isChecked();
 }

src/yuzu/configuration/configure_graphics.ui

@@ -23,31 +23,11 @@
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_2">
         <item>
-          <layout class="QHBoxLayout" name="horizontalLayout_2">
-            <item>
-              <widget class="QCheckBox" name="toggle_frame_limit">
-                <property name="text">
-                  <string>Limit Speed Percent</string>
-                </property>
-              </widget>
-            </item>
-            <item>
-              <widget class="QSpinBox" name="frame_limit">
-                <property name="suffix">
-                  <string>%</string>
-                </property>
-                <property name="minimum">
-                  <number>1</number>
-                </property>
-                <property name="maximum">
-                  <number>9999</number>
-                </property>
-                <property name="value">
-                  <number>100</number>
-                </property>
-              </widget>
-            </item>
-          </layout>
+         <widget class="QCheckBox" name="toggle_framelimit">
+          <property name="text">
+           <string>Limit framerate</string>
+          </property>
+         </widget>
         </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="buttonMiscMinusVerticalLayout">
-          <item>
-           <widget class="QLabel" name="labelMinus">
-            <property name="text">
-             <string>Minus:</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QPushButton" name="buttonMinus">
-            <property name="text">
-             <string/>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
-        <item row="0" column="1">
          <layout class="QVBoxLayout" name="buttonMiscPlusVerticalLayout">
           <item>
            <widget class="QLabel" name="labelPlus">
@@ -64,6 +46,24 @@
           </item>
          </layout>
         </item>
+        <item row="0" column="1">
+         <layout class="QVBoxLayout" name="buttonMiscMinusVerticalLayout">
+          <item>
+           <widget class="QLabel" name="labelMinus">
+            <property name="text">
+             <string>Minus:</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="buttonMinus">
+            <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/nca_metadata.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_real.h"
@@ -327,7 +328,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 OpenFolderRequested(program_id, GameListOpenTarget::SaveData); });
+            [&]() { emit OpenSaveFolderRequested(program_id); });
     context_menu.exec(tree_view->viewport()->mapToGlobal(menu_location));
 }
 

src/yuzu/game_list.h

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

src/yuzu/game_list_p.h

@@ -6,15 +6,12 @@
 
 #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

@@ -20,7 +20,6 @@
 #include "common/logging/backend.h"
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
-#include "common/logging/text_formatter.h"
 #include "common/microprofile.h"
 #include "common/scm_rev.h"
 #include "common/scope_exit.h"
@@ -30,9 +29,7 @@
 #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"
 #include "core/settings.h"
 #include "video_core/debug_utils/debug_utils.h"
@@ -216,14 +213,6 @@ 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();
 }
@@ -232,16 +221,11 @@ 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,
@@ -258,12 +242,6 @@ 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),
@@ -277,24 +255,9 @@ void GMainWindow::InitializeHotkeys() {
             });
     connect(hotkey_registry.GetHotkey("Main Window", "Toggle Speed Limit", this),
             &QShortcut::activated, this, [&] {
-                Settings::values.use_frame_limit = !Settings::values.use_frame_limit;
+                Settings::values.toggle_framelimit = !Settings::values.toggle_framelimit;
                 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() {
@@ -338,7 +301,8 @@ void GMainWindow::RestoreUIState() {
 
 void GMainWindow::ConnectWidgetEvents() {
     connect(game_list, &GameList::GameChosen, this, &GMainWindow::OnGameListLoadFile);
-    connect(game_list, &GameList::OpenFolderRequested, this, &GMainWindow::OnGameListOpenFolder);
+    connect(game_list, &GameList::OpenSaveFolderRequested, this,
+            &GMainWindow::OnGameListOpenSaveFolder);
 
     connect(this, &GMainWindow::EmulationStarting, render_window,
             &GRenderWindow::OnEmulationStarting);
@@ -362,7 +326,6 @@ 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
@@ -512,8 +475,6 @@ bool GMainWindow::LoadROM(const QString& filename) {
         }
         return false;
     }
-    game_path = filename;
-
     Core::Telemetry().AddField(Telemetry::FieldType::App, "Frontend", "Qt");
     return true;
 }
@@ -545,15 +506,6 @@ void GMainWindow::BootGame(const QString& filename) {
     }
     status_bar_update_timer.start(2000);
 
-    std::string title_name;
-    const auto res = Core::System::GetInstance().GetGameName(title_name);
-    if (res != Loader::ResultStatus::Success)
-        title_name = FileUtil::GetFilename(filename.toStdString());
-
-    setWindowTitle(QString("yuzu %1| %4 | %2-%3")
-                       .arg(Common::g_build_name, Common::g_scm_branch, Common::g_scm_desc,
-                            QString::fromStdString(title_name)));
-
     render_window->show();
     render_window->setFocus();
 
@@ -581,12 +533,9 @@ 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();
-    setWindowTitle(QString("yuzu %1| %2-%3")
-                       .arg(Common::g_build_name, Common::g_scm_branch, Common::g_scm_desc));
 
     // Disable status bar updates
     status_bar_update_timer.stop();
@@ -596,8 +545,6 @@ void GMainWindow::ShutdownGame() {
     emu_frametime_label->setVisible(false);
 
     emulation_running = false;
-
-    game_path.clear();
 }
 
 void GMainWindow::StoreRecentFile(const QString& filename) {
@@ -635,37 +582,8 @@ void GMainWindow::OnGameListLoadFile(QString game_path) {
     BootGame(game_path);
 }
 
-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::OnGameListOpenSaveFolder(u64 program_id) {
+    UNIMPLEMENTED();
 }
 
 void GMainWindow::OnMenuLoadFile() {
@@ -891,7 +809,6 @@ 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() {
@@ -993,13 +910,7 @@ void GMainWindow::UpdateStatusBar() {
 
     auto results = Core::System::GetInstance().GetAndResetPerfStats();
 
-    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));
-    }
+    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,7 +21,6 @@ class GRenderWindow;
 class MicroProfileDialog;
 class ProfilerWidget;
 class WaitTreeWidget;
-enum class GameListOpenTarget;
 
 namespace Tegra {
 class DebugContext;
@@ -123,7 +122,7 @@ private slots:
     void OnStopGame();
     /// Called whenever a user selects a game in the game list widget.
     void OnGameListLoadFile(QString game_path);
-    void OnGameListOpenFolder(u64 program_id, GameListOpenTarget target);
+    void OnGameListOpenSaveFolder(u64 program_id);
     void OnMenuLoadFile();
     void OnMenuLoadFolder();
     void OnMenuInstallToNAND();
@@ -162,8 +161,6 @@ 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,14 +211,6 @@
     <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,9 +96,8 @@ void Config::ReadValues() {
     // Renderer
     Settings::values.resolution_factor =
         (float)sdl2_config->GetReal("Renderer", "resolution_factor", 1.0);
-    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.toggle_framelimit =
+        sdl2_config->GetBoolean("Renderer", "toggle_framelimit", true);
     Settings::values.use_accurate_framebuffers =
         sdl2_config->GetBoolean("Renderer", "use_accurate_framebuffers", false);
 

src/yuzu_cmd/default_ini.h

@@ -102,14 +102,6 @@ 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 =
@@ -140,6 +132,10 @@ 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