FS: Move the file open mode calculation to a separate function.

Note that the filter parameter is not yet implemented.

.gitmodules

@@ -18,7 +18,7 @@
     url = https://github.com/fmtlib/fmt.git
 [submodule "lz4"]
     path = externals/lz4
-    url = https://github.com/lz4/lz4.git
+    url = http://github.com/lz4/lz4.git
 [submodule "unicorn"]
     path = externals/unicorn
     url = https://github.com/yuzu-emu/unicorn

CMakeLists.txt

@@ -160,9 +160,6 @@ set_property(DIRECTORY APPEND PROPERTY
     COMPILE_DEFINITIONS $<$<CONFIG:Debug>:_DEBUG> $<$<NOT:$<CONFIG:Debug>>:NDEBUG>)
 
 
-math(EXPR EMU_ARCH_BITS ${CMAKE_SIZEOF_VOID_P}*8)
-add_definitions(-DEMU_ARCH_BITS=${EMU_ARCH_BITS})
-
 # System imported libraries
 # ======================
 

externals/glad/Readme.md

@@ -1,5 +1,5 @@
 These files were generated by the [glad](https://github.com/Dav1dde/glad) OpenGL loader generator and have been checked in as-is. You can re-generate them using glad with the following command:
 
 ```
-python -m glad --profile core --out-path glad/ --api gl=3.3 --generator=c
+python -m glad --profile core --out-path glad/ --api gl=3.3,gles=3.0
 ```

externals/glad/include/KHR/khrplatform.h

@@ -26,7 +26,7 @@
 
 /* Khronos platform-specific types and definitions.
  *
- * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
+ * $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
  *
  * Adopters may modify this file to suit their platform. Adopters are
  * encouraged to submit platform specific modifications to the Khronos
@@ -101,8 +101,6 @@
 #   define KHRONOS_APICALL __declspec(dllimport)
 #elif defined (__SYMBIAN32__)
 #   define KHRONOS_APICALL IMPORT_C
-#elif defined(__ANDROID__)
-#   define KHRONOS_APICALL __attribute__((visibility("default")))
 #else
 #   define KHRONOS_APICALL
 #endif
@@ -225,7 +223,7 @@ typedef signed   short int     khronos_int16_t;
 typedef unsigned short int     khronos_uint16_t;
 
 /*
- * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * Types that differ between LLP64 and LP64 architectures - in LLP64, 
  * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
  * to be the only LLP64 architecture in current use.
  */

src/common/CMakeLists.txt

@@ -58,6 +58,7 @@ add_library(common STATIC
     misc.cpp
     param_package.cpp
     param_package.h
+    platform.h
     quaternion.h
     scm_rev.cpp
     scm_rev.h

src/common/logging/backend.cpp

@@ -37,7 +37,6 @@ namespace Log {
     SUB(Service, AM)                                                                               \
     SUB(Service, AOC)                                                                              \
     SUB(Service, APM)                                                                              \
-    SUB(Service, Fatal)                                                                            \
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \

src/common/logging/log.h

@@ -54,7 +54,6 @@ enum class Class : ClassType {
     Service_AOC,       ///< The AOC (AddOn Content) service
     Service_APM,       ///< The APM (Performance) service
     Service_Audio,     ///< The Audio (Audio control) service
-    Service_Fatal,     ///< The Fatal service
     Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) service
     Service_HID,       ///< The HID (Human interface device) service

src/common/platform.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (C) 2005-2012 Gekko Emulator
+ *
+ * @file    platform.h
+ * @author  ShizZy <shizzy247@gmail.com>
+ * @date    2012-02-11
+ * @brief   Platform detection macros for portable compilation
+ *
+ * @section LICENSE
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details at
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * Official project repository can be found at:
+ * http://code.google.com/p/gekko-gc-emu/
+ */
+
+#pragma once
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Platform detection
+
+#if defined(ARCHITECTURE_x86_64) || defined(__aarch64__)
+#define EMU_ARCH_BITS 64
+#elif defined(__i386) || defined(_M_IX86) || defined(__arm__) || defined(_M_ARM)
+#define EMU_ARCH_BITS 32
+#endif

src/core/CMakeLists.txt

@@ -22,6 +22,8 @@ add_library(core STATIC
     file_sys/romfs_filesystem.h
     file_sys/savedata_factory.cpp
     file_sys/savedata_factory.h
+    file_sys/sdmc_factory.cpp
+    file_sys/sdmc_factory.h
     file_sys/storage.h
     frontend/emu_window.cpp
     frontend/emu_window.h
@@ -114,12 +116,6 @@ add_library(core STATIC
     hle/service/audio/audren_u.h
     hle/service/audio/codecctl.cpp
     hle/service/audio/codecctl.h
-    hle/service/fatal/fatal.cpp
-    hle/service/fatal/fatal.h
-    hle/service/fatal/fatal_p.cpp
-    hle/service/fatal/fatal_p.h
-    hle/service/fatal/fatal_u.cpp
-    hle/service/fatal/fatal_u.h
     hle/service/filesystem/filesystem.cpp
     hle/service/filesystem/filesystem.h
     hle/service/filesystem/fsp_srv.cpp

src/core/arm/unicorn/arm_unicorn.cpp

@@ -53,7 +53,7 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
                                void* user_data) {
     ARM_Interface::ThreadContext ctx{};
     Core::CPU().SaveContext(ctx);
-    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x%lx, pc=0x%lx, lr=0x%lx", addr,
+    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x%llx, pc=0x%llx, lr=0x%llx", addr,
                ctx.pc, ctx.cpu_registers[30]);
     return {};
 }

src/core/core.cpp

@@ -99,15 +99,14 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
 
     ResultStatus init_result{Init(emu_window, system_mode.first.get())};
     if (init_result != ResultStatus::Success) {
-        LOG_CRITICAL(Core, "Failed to initialize system (Error %i)!",
-                     static_cast<int>(init_result));
+        LOG_CRITICAL(Core, "Failed to initialize system (Error %i)!", init_result);
         System::Shutdown();
         return init_result;
     }
 
     const Loader::ResultStatus load_result{app_loader->Load(current_process)};
     if (Loader::ResultStatus::Success != load_result) {
-        LOG_CRITICAL(Core, "Failed to load ROM (Error %i)!", static_cast<int>(load_result));
+        LOG_CRITICAL(Core, "Failed to load ROM (Error %i)!", load_result);
         System::Shutdown();
 
         switch (load_result) {

src/core/file_sys/directory.h

@@ -6,34 +6,28 @@
 
 #include <array>
 #include <cstddef>
+#include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "core/file_sys/filesystem.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // FileSys namespace
 
 namespace FileSys {
 
-// Structure of a directory entry, from http://3dbrew.org/wiki/FSDir:Read#Entry_format
-const size_t FILENAME_LENGTH = 0x20C / 2;
+// Structure of a directory entry, from
+// http://switchbrew.org/index.php?title=Filesystem_services#DirectoryEntry
+const size_t FILENAME_LENGTH = 0x300;
 struct Entry {
-    char16_t filename[FILENAME_LENGTH]; // Entry name (UTF-16, null-terminated)
-    std::array<char, 9> short_name; // 8.3 file name ('longfilename' -> 'LONGFI~1', null-terminated)
-    char unknown1;                  // unknown (observed values: 0x0A, 0x70, 0xFD)
-    std::array<char, 4>
-        extension;     // 8.3 file extension (set to spaces for directories, null-terminated)
-    char unknown2;     // unknown (always 0x01)
-    char unknown3;     // unknown (0x00 or 0x08)
-    char is_directory; // directory flag
-    char is_hidden;    // hidden flag
-    char is_archive;   // archive flag
-    char is_read_only; // read-only flag
-    u64 file_size;     // file size (for files only)
+    char filename[FILENAME_LENGTH];
+    INSERT_PADDING_BYTES(4);
+    EntryType type;
+    INSERT_PADDING_BYTES(3);
+    u64 file_size;
 };
-static_assert(sizeof(Entry) == 0x228, "Directory Entry struct isn't exactly 0x228 bytes long!");
-static_assert(offsetof(Entry, short_name) == 0x20C, "Wrong offset for short_name in Entry.");
-static_assert(offsetof(Entry, extension) == 0x216, "Wrong offset for extension in Entry.");
-static_assert(offsetof(Entry, is_archive) == 0x21E, "Wrong offset for is_archive in Entry.");
-static_assert(offsetof(Entry, file_size) == 0x220, "Wrong offset for file_size in Entry.");
+static_assert(sizeof(Entry) == 0x310, "Directory Entry struct isn't exactly 0x310 bytes long!");
+static_assert(offsetof(Entry, type) == 0x304, "Wrong offset for type in Entry.");
+static_assert(offsetof(Entry, file_size) == 0x308, "Wrong offset for file_size in Entry.");
 
 class DirectoryBackend : NonCopyable {
 public:
@@ -46,7 +40,10 @@ public:
      * @param entries Buffer to read data into
      * @return Number of entries listed
      */
-    virtual u32 Read(const u32 count, Entry* entries) = 0;
+    virtual u64 Read(const u64 count, Entry* entries) = 0;
+
+    /// Returns the number of entries still left to read.
+    virtual u64 GetEntryCount() const = 0;
 
     /**
      * Close the directory

src/core/file_sys/disk_filesystem.cpp

@@ -11,16 +11,43 @@
 
 namespace FileSys {
 
+static std::string ModeFlagsToString(Mode mode) {
+    std::string mode_str;
+    u32 mode_flags = static_cast<u32>(mode);
+
+    // Calculate the correct open mode for the file.
+    if ((mode_flags & static_cast<u32>(Mode::Read)) &&
+        (mode_flags & static_cast<u32>(Mode::Write))) {
+        if (mode_flags & static_cast<u32>(Mode::Append))
+            mode_str = "a+";
+        else
+            mode_str = "r+";
+    } else {
+        if (mode_flags & static_cast<u32>(Mode::Read))
+            mode_str = "r";
+        else if (mode_flags & static_cast<u32>(Mode::Append))
+            mode_str = "a";
+        else if (mode_flags & static_cast<u32>(Mode::Write))
+            mode_str = "w";
+    }
+
+    mode_str += "b";
+
+    return mode_str;
+}
+
 std::string Disk_FileSystem::GetName() const {
     return "Disk";
 }
 
 ResultVal<std::unique_ptr<StorageBackend>> Disk_FileSystem::OpenFile(const std::string& path,
                                                                      Mode mode) const {
-    ASSERT_MSG(mode == Mode::Read || mode == Mode::Write, "Other file modes are not supported");
+
+    // Calculate the correct open mode for the file.
+    std::string mode_str = ModeFlagsToString(mode);
 
     std::string full_path = base_directory + path;
-    auto file = std::make_shared<FileUtil::IOFile>(full_path, mode == Mode::Read ? "rb" : "wb");
+    auto file = std::make_shared<FileUtil::IOFile>(full_path, mode_str.c_str());
 
     if (!file->IsOpen()) {
         return ERROR_PATH_NOT_FOUND;
@@ -75,8 +102,15 @@ ResultCode Disk_FileSystem::CreateFile(const std::string& path, u64 size) const
     return ResultCode(-1);
 }
 
-ResultCode Disk_FileSystem::CreateDirectory(const Path& path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
+ResultCode Disk_FileSystem::CreateDirectory(const std::string& path) const {
+    // TODO(Subv): Perform path validation to prevent escaping the emulator sandbox.
+    std::string full_path = base_directory + path;
+
+    if (FileUtil::CreateDir(full_path)) {
+        return RESULT_SUCCESS;
+    }
+
+    LOG_CRITICAL(Service_FS, "(unreachable) Unknown error creating %s", full_path.c_str());
     // TODO(wwylele): Use correct error code
     return ResultCode(-1);
 }
@@ -88,8 +122,17 @@ ResultCode Disk_FileSystem::RenameDirectory(const Path& src_path, const Path& de
 }
 
 ResultVal<std::unique_ptr<DirectoryBackend>> Disk_FileSystem::OpenDirectory(
-    const Path& path) const {
-    return MakeResult<std::unique_ptr<DirectoryBackend>>(std::make_unique<Disk_Directory>());
+    const std::string& path) const {
+
+    std::string full_path = base_directory + path;
+
+    if (!FileUtil::IsDirectory(full_path)) {
+        // TODO(Subv): Find the correct error code for this.
+        return ResultCode(-1);
+    }
+
+    auto directory = std::make_unique<Disk_Directory>(full_path);
+    return MakeResult<std::unique_ptr<DirectoryBackend>>(std::move(directory));
 }
 
 u64 Disk_FileSystem::GetFreeSpaceSize() const {
@@ -103,8 +146,10 @@ ResultVal<FileSys::EntryType> Disk_FileSystem::GetEntryType(const std::string& p
         return ERROR_PATH_NOT_FOUND;
     }
 
-    // TODO(Subv): Find out the EntryType values
-    UNIMPLEMENTED_MSG("Unimplemented GetEntryType");
+    if (FileUtil::IsDirectory(full_path))
+        return MakeResult(EntryType::Directory);
+
+    return MakeResult(EntryType::File);
 }
 
 ResultVal<size_t> Disk_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
@@ -133,14 +178,50 @@ bool Disk_Storage::SetSize(const u64 size) const {
     return false;
 }
 
-u32 Disk_Directory::Read(const u32 count, Entry* entries) {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    return 0;
+Disk_Directory::Disk_Directory(const std::string& path) : directory() {
+    unsigned size = FileUtil::ScanDirectoryTree(path, directory);
+    directory.size = size;
+    directory.isDirectory = true;
+    children_iterator = directory.children.begin();
 }
 
-bool Disk_Directory::Close() const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    return true;
+u64 Disk_Directory::Read(const u64 count, Entry* entries) {
+    u64 entries_read = 0;
+
+    while (entries_read < count && children_iterator != directory.children.cend()) {
+        const FileUtil::FSTEntry& file = *children_iterator;
+        const std::string& filename = file.virtualName;
+        Entry& entry = entries[entries_read];
+
+        LOG_TRACE(Service_FS, "File %s: size=%llu dir=%d", filename.c_str(), file.size,
+                  file.isDirectory);
+
+        // TODO(Link Mauve): use a proper conversion to UTF-16.
+        for (size_t j = 0; j < FILENAME_LENGTH; ++j) {
+            entry.filename[j] = filename[j];
+            if (!filename[j])
+                break;
+        }
+
+        if (file.isDirectory) {
+            entry.file_size = 0;
+            entry.type = EntryType::Directory;
+        } else {
+            entry.file_size = file.size;
+            entry.type = EntryType::File;
+        }
+
+        ++entries_read;
+        ++children_iterator;
+    }
+    return entries_read;
+}
+
+u64 Disk_Directory::GetEntryCount() const {
+    // We convert the children iterator into a const_iterator to allow template argument deduction
+    // in std::distance.
+    std::vector<FileUtil::FSTEntry>::const_iterator current = children_iterator;
+    return std::distance(current, directory.children.end());
 }
 
 } // namespace FileSys

src/core/file_sys/disk_filesystem.h

@@ -30,9 +30,10 @@ public:
     ResultCode DeleteDirectory(const Path& path) const override;
     ResultCode DeleteDirectoryRecursively(const Path& path) const override;
     ResultCode CreateFile(const std::string& path, u64 size) const override;
-    ResultCode CreateDirectory(const Path& path) const override;
+    ResultCode CreateDirectory(const std::string& path) const override;
     ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
-    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
+    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
+        const std::string& path) const override;
     u64 GetFreeSpaceSize() const override;
     ResultVal<EntryType> GetEntryType(const std::string& path) const override;
 
@@ -59,8 +60,26 @@ private:
 
 class Disk_Directory : public DirectoryBackend {
 public:
-    u32 Read(const u32 count, Entry* entries) override;
-    bool Close() const override;
+    Disk_Directory(const std::string& path);
+
+    ~Disk_Directory() override {
+        Close();
+    }
+
+    u64 Read(const u64 count, Entry* entries) override;
+    u64 GetEntryCount() const override;
+
+    bool Close() const override {
+        return true;
+    }
+
+protected:
+    u32 total_entries_in_directory;
+    FileUtil::FSTEntry directory;
+
+    // We need to remember the last entry we returned, so a subsequent call to Read will continue
+    // from the next one. This iterator will always point to the next unread entry.
+    std::vector<FileUtil::FSTEntry>::iterator children_iterator;
 };
 
 } // namespace FileSys

src/core/file_sys/filesystem.h

@@ -27,7 +27,7 @@ enum LowPathType : u32 {
     Wchar = 4,
 };
 
-enum EntryType : u32 {
+enum EntryType : u8 {
     Directory = 0,
     File = 1,
 };
@@ -35,6 +35,7 @@ enum EntryType : u32 {
 enum class Mode : u32 {
     Read = 1,
     Write = 2,
+    Append = 4,
 };
 
 class Path {
@@ -103,7 +104,7 @@ public:
      * @param path Path relative to the archive
      * @return Result of the operation
      */
-    virtual ResultCode CreateDirectory(const Path& path) const = 0;
+    virtual ResultCode CreateDirectory(const std::string& path) const = 0;
 
     /**
      * Delete a directory specified by its path
@@ -149,7 +150,8 @@ public:
      * @param path Path relative to the archive
      * @return Opened directory, or error code
      */
-    virtual ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const = 0;
+    virtual ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
+        const std::string& path) const = 0;
 
     /**
      * Get the free space

src/core/file_sys/romfs_filesystem.cpp

@@ -55,7 +55,7 @@ ResultCode RomFS_FileSystem::CreateFile(const std::string& path, u64 size) const
     return ResultCode(-1);
 }
 
-ResultCode RomFS_FileSystem::CreateDirectory(const Path& path) const {
+ResultCode RomFS_FileSystem::CreateDirectory(const std::string& path) const {
     LOG_CRITICAL(Service_FS, "Attempted to create a directory in an ROMFS archive (%s).",
                  GetName().c_str());
     // TODO(wwylele): Use correct error code
@@ -70,7 +70,8 @@ ResultCode RomFS_FileSystem::RenameDirectory(const Path& src_path, const Path& d
 }
 
 ResultVal<std::unique_ptr<DirectoryBackend>> RomFS_FileSystem::OpenDirectory(
-    const Path& path) const {
+    const std::string& path) const {
+    LOG_WARNING(Service_FS, "Opening Directory in a ROMFS archive");
     return MakeResult<std::unique_ptr<DirectoryBackend>>(std::make_unique<ROMFSDirectory>());
 }
 

src/core/file_sys/romfs_filesystem.h

@@ -36,9 +36,10 @@ public:
     ResultCode DeleteDirectory(const Path& path) const override;
     ResultCode DeleteDirectoryRecursively(const Path& path) const override;
     ResultCode CreateFile(const std::string& path, u64 size) const override;
-    ResultCode CreateDirectory(const Path& path) const override;
+    ResultCode CreateDirectory(const std::string& path) const override;
     ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
-    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
+    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
+        const std::string& path) const override;
     u64 GetFreeSpaceSize() const override;
     ResultVal<EntryType> GetEntryType(const std::string& path) const override;
 
@@ -70,7 +71,10 @@ private:
 
 class ROMFSDirectory : public DirectoryBackend {
 public:
-    u32 Read(const u32 count, Entry* entries) override {
+    u64 Read(const u64 count, Entry* entries) override {
+        return 0;
+    }
+    u64 GetEntryCount() const override {
         return 0;
     }
     bool Close() const override {

src/core/file_sys/sdmc_factory.cpp

@@ -0,0 +1,40 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cinttypes>
+#include <memory>
+#include "common/common_types.h"
+#include "common/logging/log.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/file_sys/disk_filesystem.h"
+#include "core/file_sys/sdmc_factory.h"
+
+namespace FileSys {
+
+SDMC_Factory::SDMC_Factory(std::string sd_directory) : sd_directory(std::move(sd_directory)) {}
+
+ResultVal<std::unique_ptr<FileSystemBackend>> SDMC_Factory::Open(const Path& path) {
+    // Create the SD Card directory if it doesn't already exist.
+    if (!FileUtil::IsDirectory(sd_directory)) {
+        FileUtil::CreateFullPath(sd_directory);
+    }
+
+    auto archive = std::make_unique<Disk_FileSystem>(sd_directory);
+    return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
+}
+
+ResultCode SDMC_Factory::Format(const Path& path) {
+    LOG_ERROR(Service_FS, "Unimplemented Format archive %s", GetName().c_str());
+    // TODO(Subv): Find the right error code for this
+    return ResultCode(-1);
+}
+
+ResultVal<ArchiveFormatInfo> SDMC_Factory::GetFormatInfo(const Path& path) const {
+    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive %s", GetName().c_str());
+    // TODO(bunnei): Find the right error code for this
+    return ResultCode(-1);
+}
+
+} // namespace FileSys

src/core/file_sys/sdmc_factory.h

@@ -0,0 +1,31 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include "common/common_types.h"
+#include "core/file_sys/filesystem.h"
+#include "core/hle/result.h"
+
+namespace FileSys {
+
+/// File system interface to the SDCard archive
+class SDMC_Factory final : public FileSystemFactory {
+public:
+    explicit SDMC_Factory(std::string sd_directory);
+
+    std::string GetName() const override {
+        return "SDMC_Factory";
+    }
+    ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
+    ResultCode Format(const Path& path) override;
+    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
+
+private:
+    std::string sd_directory;
+};
+
+} // namespace FileSys

src/core/gdbstub/gdbstub.cpp

@@ -693,7 +693,7 @@ static void ReadMemory() {
     u64 len =
         HexToLong(start_offset, static_cast<u64>((command_buffer + command_length) - start_offset));
 
-    LOG_DEBUG(Debug_GDBStub, "gdb: addr: %016lx len: %016lx\n", addr, len);
+    LOG_DEBUG(Debug_GDBStub, "gdb: addr: %016llx len: %016llx\n", addr, len);
 
     if (len * 2 > sizeof(reply)) {
         SendReply("E01");

src/core/hle/kernel/hle_ipc.cpp

@@ -269,7 +269,7 @@ std::vector<u8> HLERequestContext::ReadBuffer() const {
 size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size) const {
     const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
 
-    ASSERT_MSG(size <= GetWriteBufferSize(), "Size %lx is too big", size);
+    ASSERT_MSG(size <= GetWriteBufferSize(), "Size %d is too big", size);
 
     if (is_buffer_b) {
         Memory::WriteBlock(BufferDescriptorB()[0].Address(), buffer, size);

src/core/hle/kernel/object_address_table.cpp

@@ -10,12 +10,12 @@ namespace Kernel {
 ObjectAddressTable g_object_address_table;
 
 void ObjectAddressTable::Insert(VAddr addr, SharedPtr<Object> obj) {
-    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x%lx", addr);
+    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x%llx", addr);
     objects[addr] = obj;
 }
 
 void ObjectAddressTable::Close(VAddr addr) {
-    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x%lx", addr);
+    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x%llx", addr);
     objects.erase(addr);
 }
 

src/core/hle/kernel/server_session.cpp

@@ -78,8 +78,7 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
         }
         }
 
-        LOG_CRITICAL(IPC, "Unknown domain command=%d",
-                     static_cast<int>(domain_message_header->command.Value()));
+        LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
         ASSERT(false);
     }
 

src/core/hle/kernel/shared_memory.cpp

@@ -107,7 +107,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
 
     // Error out if the requested permissions don't match what the creator process allows.
     if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
-        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, permissions don't match",
+        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%llx name=%s, permissions don't match",
                   GetObjectId(), address, name.c_str());
         return ERR_INVALID_COMBINATION;
     }
@@ -115,7 +115,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
     // Error out if the provided permissions are not compatible with what the creator process needs.
     if (other_permissions != MemoryPermission::DontCare &&
         static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
-        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, permissions don't match",
+        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%llx name=%s, permissions don't match",
                   GetObjectId(), address, name.c_str());
         return ERR_WRONG_PERMISSION;
     }
@@ -126,7 +126,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
     if (address != 0) {
         // TODO(shinyquagsire23): Check for virtual/mappable memory here too?
         if (address >= Memory::HEAP_VADDR && address < Memory::HEAP_VADDR_END) {
-            LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, invalid address",
+            LOG_ERROR(Kernel, "cannot map id=%u, address=0x%llx name=%s, invalid address",
                       GetObjectId(), address, name.c_str());
             return ERR_INVALID_ADDRESS;
         }
@@ -143,9 +143,10 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
     auto result = target_process->vm_manager.MapMemoryBlock(
         target_address, backing_block, backing_block_offset, size, MemoryState::Shared);
     if (result.Failed()) {
-        LOG_ERROR(Kernel,
-                  "cannot map id=%u, target_address=0x%lx name=%s, error mapping to virtual memory",
-                  GetObjectId(), target_address, name.c_str());
+        LOG_ERROR(
+            Kernel,
+            "cannot map id=%u, target_address=0x%llx name=%s, error mapping to virtual memory",
+            GetObjectId(), target_address, name.c_str());
         return result.Code();
     }
 

src/core/hle/kernel/svc.cpp

@@ -39,7 +39,7 @@ static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
 }
 
 static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x%lx", addr);
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x%llx", addr);
     return RESULT_SUCCESS;
 }
 
@@ -750,7 +750,7 @@ static ResultCode ResetSignal(Handle handle) {
 
 /// Creates a TransferMemory object
 static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32 permissions) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x%lx, size=0x%lx, perms=%08X", addr, size,
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x%llx, size=0x%llx, perms=%08X", addr, size,
                 permissions);
     *handle = 0;
     return RESULT_SUCCESS;

src/core/hle/service/fatal/fatal.cpp

@@ -1,38 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/fatal/fatal.h"
-#include "core/hle/service/fatal/fatal_p.h"
-#include "core/hle/service/fatal/fatal_u.h"
-
-namespace Service {
-namespace Fatal {
-
-Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {}
-
-void Module::Interface::FatalSimple(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp(ctx);
-    u32 error_code = rp.Pop<u32>();
-    LOG_WARNING(Service_Fatal, "(STUBBED) called, error_code=0x%X", error_code);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Module::Interface::TransitionToFatalError(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_Fatal, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void InstallInterfaces(SM::ServiceManager& service_manager) {
-    auto module = std::make_shared<Module>();
-    std::make_shared<Fatal_P>(module)->InstallAsService(service_manager);
-    std::make_shared<Fatal_U>(module)->InstallAsService(service_manager);
-}
-
-} // namespace Fatal
-} // namespace Service

src/core/hle/service/fatal/fatal.h

@@ -1,29 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace Fatal {
-
-class Module final {
-public:
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        Interface(std::shared_ptr<Module> module, const char* name);
-
-        void FatalSimple(Kernel::HLERequestContext& ctx);
-        void TransitionToFatalError(Kernel::HLERequestContext& ctx);
-
-    protected:
-        std::shared_ptr<Module> module;
-    };
-};
-
-void InstallInterfaces(SM::ServiceManager& service_manager);
-
-} // namespace Fatal
-} // namespace Service

src/core/hle/service/fatal/fatal_p.cpp

@@ -1,14 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/fatal/fatal_p.h"
-
-namespace Service {
-namespace Fatal {
-
-Fatal_P::Fatal_P(std::shared_ptr<Module> module)
-    : Module::Interface(std::move(module), "fatal:p") {}
-
-} // namespace Fatal
-} // namespace Service

src/core/hle/service/fatal/fatal_p.h

@@ -1,18 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/fatal/fatal.h"
-
-namespace Service {
-namespace Fatal {
-
-class Fatal_P final : public Module::Interface {
-public:
-    explicit Fatal_P(std::shared_ptr<Module> module);
-};
-
-} // namespace Fatal
-} // namespace Service

src/core/hle/service/fatal/fatal_u.cpp

@@ -1,19 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/fatal/fatal_u.h"
-
-namespace Service {
-namespace Fatal {
-
-Fatal_U::Fatal_U(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "fatal:u") {
-    static const FunctionInfo functions[] = {
-        {1, &Fatal_U::FatalSimple, "FatalSimple"},
-        {2, &Fatal_U::TransitionToFatalError, "TransitionToFatalError"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Fatal
-} // namespace Service

src/core/hle/service/fatal/fatal_u.h

@@ -1,18 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/fatal/fatal.h"
-
-namespace Service {
-namespace Fatal {
-
-class Fatal_U final : public Module::Interface {
-public:
-    explicit Fatal_U(std::shared_ptr<Module> module);
-};
-
-} // namespace Fatal
-} // namespace Service

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

@@ -6,6 +6,7 @@
 #include "common/file_util.h"
 #include "core/file_sys/filesystem.h"
 #include "core/file_sys/savedata_factory.h"
+#include "core/file_sys/sdmc_factory.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
 
@@ -60,9 +61,13 @@ void RegisterFileSystems() {
     filesystem_map.clear();
 
     std::string nand_directory = FileUtil::GetUserPath(D_NAND_IDX);
+    std::string sd_directory = FileUtil::GetUserPath(D_SDMC_IDX);
 
     auto savedata = std::make_unique<FileSys::SaveData_Factory>(std::move(nand_directory));
     RegisterFileSystem(std::move(savedata), Type::SaveData);
+
+    auto sdcard = std::make_unique<FileSys::SDMC_Factory>(std::move(sd_directory));
+    RegisterFileSystem(std::move(sdcard), Type::SDMC);
 }
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {

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

@@ -26,6 +26,7 @@ namespace FileSystem {
 enum class Type {
     RomFS = 1,
     SaveData = 2,
+    SDMC = 3,
 };
 
 /**

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

@@ -5,6 +5,7 @@
 #include <cinttypes>
 #include "common/logging/log.h"
 #include "core/core.h"
+#include "core/file_sys/directory.h"
 #include "core/file_sys/filesystem.h"
 #include "core/file_sys/storage.h"
 #include "core/hle/ipc_helpers.h"
@@ -35,7 +36,7 @@ private:
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        LOG_DEBUG(Service_FS, "called, offset=0x%ld, length=0x%ld", offset, length);
+        LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
 
         // Error checking
         if (length < 0) {
@@ -86,7 +87,7 @@ private:
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        LOG_DEBUG(Service_FS, "called, offset=0x%ld, length=0x%ld", offset, length);
+        LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
 
         // Error checking
         if (length < 0) {
@@ -123,7 +124,7 @@ private:
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        LOG_DEBUG(Service_FS, "called, offset=0x%ld, length=0x%ld", offset, length);
+        LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
 
         // Error checking
         if (length < 0) {
@@ -151,14 +152,66 @@ private:
     }
 };
 
+class IDirectory final : public ServiceFramework<IDirectory> {
+public:
+    explicit IDirectory(std::unique_ptr<FileSys::DirectoryBackend>&& backend)
+        : ServiceFramework("IDirectory"), backend(std::move(backend)) {
+        static const FunctionInfo functions[] = {
+            {0, &IDirectory::Read, "Read"},
+            {1, &IDirectory::GetEntryCount, "GetEntryCount"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    std::unique_ptr<FileSys::DirectoryBackend> backend;
+
+    void Read(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u64 unk = rp.Pop<u64>();
+
+        LOG_DEBUG(Service_FS, "called, unk=0x%llx", unk);
+
+        // Calculate how many entries we can fit in the output buffer
+        u64 count_entries = ctx.GetWriteBufferSize() / sizeof(FileSys::Entry);
+
+        // Read the data from the Directory backend
+        std::vector<FileSys::Entry> entries(count_entries);
+        u64 read_entries = backend->Read(count_entries, entries.data());
+
+        // Convert the data into a byte array
+        std::vector<u8> output(entries.size() * sizeof(FileSys::Entry));
+        std::memcpy(output.data(), entries.data(), output.size());
+
+        // Write the data to memory
+        ctx.WriteBuffer(output);
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(read_entries);
+    }
+
+    void GetEntryCount(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_FS, "called");
+
+        u64 count = backend->GetEntryCount();
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(count);
+    }
+};
+
 class IFileSystem final : public ServiceFramework<IFileSystem> {
 public:
     explicit IFileSystem(std::unique_ptr<FileSys::FileSystemBackend>&& backend)
         : ServiceFramework("IFileSystem"), backend(std::move(backend)) {
         static const FunctionInfo functions[] = {
             {0, &IFileSystem::CreateFile, "CreateFile"},
+            {2, &IFileSystem::CreateDirectory, "CreateDirectory"},
             {7, &IFileSystem::GetEntryType, "GetEntryType"},
             {8, &IFileSystem::OpenFile, "OpenFile"},
+            {9, &IFileSystem::OpenDirectory, "OpenDirectory"},
             {10, &IFileSystem::Commit, "Commit"},
         };
         RegisterHandlers(functions);
@@ -182,6 +235,20 @@ public:
         rb.Push(backend->CreateFile(name, size));
     }
 
+    void CreateDirectory(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        auto file_buffer = ctx.ReadBuffer();
+        auto end = std::find(file_buffer.begin(), file_buffer.end(), '\0');
+
+        std::string name(file_buffer.begin(), end);
+
+        LOG_DEBUG(Service_FS, "called directory %s", name.c_str());
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(backend->CreateDirectory(name));
+    }
+
     void OpenFile(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
@@ -208,6 +275,33 @@ public:
         rb.PushIpcInterface<IFile>(std::move(file));
     }
 
+    void OpenDirectory(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        auto file_buffer = ctx.ReadBuffer();
+        auto end = std::find(file_buffer.begin(), file_buffer.end(), '\0');
+
+        std::string name(file_buffer.begin(), end);
+
+        // TODO(Subv): Implement this filter.
+        u32 filter_flags = rp.Pop<u32>();
+
+        LOG_DEBUG(Service_FS, "called directory %s filter %u", name.c_str(), filter_flags);
+
+        auto result = backend->OpenDirectory(name);
+        if (result.Failed()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(result.Code());
+            return;
+        }
+
+        auto directory = std::move(result.Unwrap());
+
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IDirectory>(std::move(directory));
+    }
+
     void GetEntryType(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
@@ -274,10 +368,14 @@ void FSP_SRV::Initalize(Kernel::HLERequestContext& ctx) {
 }
 
 void FSP_SRV::MountSdCard(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_DEBUG(Service_FS, "called");
 
-    IPC::ResponseBuilder rb{ctx, 2};
+    FileSys::Path unused;
+    auto filesystem = OpenFileSystem(Type::SDMC, unused).Unwrap();
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IFileSystem>(std::move(filesystem));
 }
 
 void FSP_SRV::CreateSaveData(Kernel::HLERequestContext& ctx) {

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

@@ -23,16 +23,17 @@ void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u3
                         u32 stride, NVFlinger::BufferQueue::BufferTransformFlags transform) {
     VAddr addr = nvmap_dev->GetObjectAddress(buffer_handle);
     LOG_WARNING(Service,
-                "Drawing from address %lx offset %08X Width %u Height %u Stride %u Format %u", addr,
-                offset, width, height, stride, format);
+                "Drawing from address %llx offset %08X Width %u Height %u Stride %u Format %u",
+                addr, offset, width, height, stride, format);
 
-    using PixelFormat = Tegra::FramebufferConfig::PixelFormat;
-    const Tegra::FramebufferConfig framebuffer{
-        addr, offset, width, height, stride, static_cast<PixelFormat>(format), transform};
+    using PixelFormat = RendererBase::FramebufferInfo::PixelFormat;
+    using Flags = NVFlinger::BufferQueue::BufferTransformFlags;
+    const bool flip_vertical = static_cast<u32>(transform) & static_cast<u32>(Flags::FlipV);
+    const RendererBase::FramebufferInfo framebuffer_info{
+        addr, offset, width, height, stride, static_cast<PixelFormat>(format), flip_vertical};
 
     Core::System::GetInstance().perf_stats.EndGameFrame();
-
-    VideoCore::g_renderer->SwapBuffers(framebuffer);
+    VideoCore::g_renderer->SwapBuffers(framebuffer_info);
 }
 
 } // namespace Devices

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

@@ -47,8 +47,6 @@ public:
     ~BufferQueue() = default;
 
     enum class BufferTransformFlags : u32 {
-        /// No transform flags are set
-        Unset = 0x00,
         /// Flip source image horizontally (around the vertical axis)
         FlipH = 0x01,
         /// Flip source image vertically (around the horizontal axis)

src/core/hle/service/service.cpp

@@ -20,7 +20,6 @@
 #include "core/hle/service/aoc/aoc_u.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/audio/audio.h"
-#include "core/hle/service/fatal/fatal.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/friend/friend.h"
 #include "core/hle/service/hid/hid.h"
@@ -150,7 +149,7 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
         break;
     }
     default:
-        UNIMPLEMENTED_MSG("command_type=%d", static_cast<int>(context.GetCommandType()));
+        UNIMPLEMENTED_MSG("command_type=%d", context.GetCommandType());
     }
 
     context.WriteToOutgoingCommandBuffer(*Kernel::GetCurrentThread());
@@ -180,7 +179,6 @@ void Init() {
     AOC::InstallInterfaces(*SM::g_service_manager);
     APM::InstallInterfaces(*SM::g_service_manager);
     Audio::InstallInterfaces(*SM::g_service_manager);
-    Fatal::InstallInterfaces(*SM::g_service_manager);
     FileSystem::InstallInterfaces(*SM::g_service_manager);
     Friend::InstallInterfaces(*SM::g_service_manager);
     HID::InstallInterfaces(*SM::g_service_manager);

src/core/hle/service/time/time.cpp

@@ -107,7 +107,7 @@ private:
         IPC::RequestParser rp{ctx};
         u64 posix_time = rp.Pop<u64>();
 
-        LOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x%016lX", posix_time);
+        LOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x%016llX", posix_time);
 
         CalendarTime calendar_time{2018, 1, 1, 0, 0, 0};
         CalendarAdditionalInfo additional_info{};

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

@@ -4,13 +4,10 @@
 
 #include <algorithm>
 #include <array>
-#include <memory>
-#include <boost/optional.hpp>
 #include "common/alignment.h"
 #include "common/scope_exit.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 #include "core/hle/service/vi/vi.h"
@@ -474,7 +471,7 @@ private:
         u32 flags = rp.Pop<u32>();
         auto buffer_queue = nv_flinger->GetBufferQueue(id);
 
-        LOG_DEBUG(Service_VI, "called, transaction=%x", static_cast<u32>(transaction));
+        LOG_DEBUG(Service_VI, "called, transaction=%x", transaction);
 
         if (transaction == TransactionId::Connect) {
             IGBPConnectRequestParcel request{ctx.ReadBuffer()};
@@ -649,152 +646,144 @@ private:
     std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
-class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
-public:
-    IApplicationDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
-    ~IApplicationDisplayService() = default;
+void IApplicationDisplayService::GetRelayService(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
 
-private:
-    void GetRelayService(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
+}
 
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
-    }
+void IApplicationDisplayService::GetSystemDisplayService(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
 
-    void GetSystemDisplayService(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<ISystemDisplayService>();
+}
 
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ISystemDisplayService>();
-    }
+void IApplicationDisplayService::GetManagerDisplayService(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
 
-    void GetManagerDisplayService(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IManagerDisplayService>(nv_flinger);
+}
 
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IManagerDisplayService>(nv_flinger);
-    }
+void IApplicationDisplayService::GetIndirectDisplayTransactionService(
+    Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
 
-    void GetIndirectDisplayTransactionService(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
+}
 
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
-    }
+void IApplicationDisplayService::OpenDisplay(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+    IPC::RequestParser rp{ctx};
+    auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
+    auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
 
-    void OpenDisplay(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-        IPC::RequestParser rp{ctx};
-        auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
-        auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
+    std::string name(name_buf.begin(), end);
 
-        std::string name(name_buf.begin(), end);
+    ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
 
-        ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
+    IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u64>(nv_flinger->OpenDisplay(name));
+}
 
-        IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(nv_flinger->OpenDisplay(name));
-    }
+void IApplicationDisplayService::CloseDisplay(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+    IPC::RequestParser rp{ctx};
+    u64 display_id = rp.Pop<u64>();
 
-    void CloseDisplay(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-        IPC::RequestParser rp{ctx};
-        u64 display_id = rp.Pop<u64>();
+    IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+    rb.Push(RESULT_SUCCESS);
+}
 
-        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-    }
+void IApplicationDisplayService::OpenLayer(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_VI, "called");
+    IPC::RequestParser rp{ctx};
+    auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
+    auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
 
-    void SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-        IPC::RequestParser rp{ctx};
-        u32 scaling_mode = rp.Pop<u32>();
-        u64 unknown = rp.Pop<u64>();
+    std::string display_name(name_buf.begin(), end);
 
-        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-    }
+    u64 layer_id = rp.Pop<u64>();
+    u64 aruid = rp.Pop<u64>();
 
-    void ListDisplays(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        DisplayInfo display_info;
-        ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
-        IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(1);
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-    }
+    u64 display_id = nv_flinger->OpenDisplay(display_name);
+    u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
 
-    void OpenLayer(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_VI, "called");
-        IPC::RequestParser rp{ctx};
-        auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
-        auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
+    NativeWindow native_window{buffer_queue_id};
+    IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
+}
 
-        std::string display_name(name_buf.begin(), end);
+void IApplicationDisplayService::CreateStrayLayer(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_VI, "called");
 
-        u64 layer_id = rp.Pop<u64>();
-        u64 aruid = rp.Pop<u64>();
+    IPC::RequestParser rp{ctx};
+    u32 flags = rp.Pop<u32>();
+    rp.Pop<u32>(); // padding
+    u64 display_id = rp.Pop<u64>();
 
-        u64 display_id = nv_flinger->OpenDisplay(display_name);
-        u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
+    // TODO(Subv): What's the difference between a Stray and a Managed layer?
 
-        NativeWindow native_window{buffer_queue_id};
-        IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
-    }
+    u64 layer_id = nv_flinger->CreateLayer(display_id);
+    u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
 
-    void CreateStrayLayer(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_VI, "called");
+    NativeWindow native_window{buffer_queue_id};
+    IPC::ResponseBuilder rb = rp.MakeBuilder(6, 0, 0);
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(layer_id);
+    rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
+}
 
-        IPC::RequestParser rp{ctx};
-        u32 flags = rp.Pop<u32>();
-        rp.Pop<u32>(); // padding
-        u64 display_id = rp.Pop<u64>();
+void IApplicationDisplayService::DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
 
-        // TODO(Subv): What's the difference between a Stray and a Managed layer?
+    IPC::RequestParser rp{ctx};
+    u64 layer_id = rp.Pop<u64>();
 
-        u64 layer_id = nv_flinger->CreateLayer(display_id);
-        u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
+    IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+    rb.Push(RESULT_SUCCESS);
+}
 
-        NativeWindow native_window{buffer_queue_id};
-        IPC::ResponseBuilder rb = rp.MakeBuilder(6, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(layer_id);
-        rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
-    }
+void IApplicationDisplayService::SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+    IPC::RequestParser rp{ctx};
+    u32 scaling_mode = rp.Pop<u32>();
+    u64 unknown = rp.Pop<u64>();
 
-    void DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
+    IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+    rb.Push(RESULT_SUCCESS);
+}
 
-        IPC::RequestParser rp{ctx};
-        u64 layer_id = rp.Pop<u64>();
+void IApplicationDisplayService::ListDisplays(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    DisplayInfo display_info;
+    ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
+    IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u64>(1);
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+}
 
-        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-    }
+void IApplicationDisplayService::GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+    IPC::RequestParser rp{ctx};
+    u64 display_id = rp.Pop<u64>();
 
-    void GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-        IPC::RequestParser rp{ctx};
-        u64 display_id = rp.Pop<u64>();
+    auto vsync_event = nv_flinger->GetVsyncEvent(display_id);
 
-        auto vsync_event = nv_flinger->GetVsyncEvent(display_id);
-
-        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 1, 0);
-        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(vsync_event);
-    }
-
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
-};
+    IPC::ResponseBuilder rb = rp.MakeBuilder(2, 1, 0);
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(vsync_event);
+}
 
 IApplicationDisplayService::IApplicationDisplayService(
     std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
@@ -817,24 +806,11 @@ IApplicationDisplayService::IApplicationDisplayService(
     RegisterHandlers(functions);
 }
 
-Module::Interface::Interface(std::shared_ptr<Module> module, const char* name,
-                             std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : ServiceFramework(name), module(std::move(module)), nv_flinger(std::move(nv_flinger)) {}
-
-void Module::Interface::GetDisplayService(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
-}
-
 void InstallInterfaces(SM::ServiceManager& service_manager,
                        std::shared_ptr<NVFlinger::NVFlinger> nv_flinger) {
-    auto module = std::make_shared<Module>();
-    std::make_shared<VI_M>(module, nv_flinger)->InstallAsService(service_manager);
-    std::make_shared<VI_S>(module, nv_flinger)->InstallAsService(service_manager);
-    std::make_shared<VI_U>(module, nv_flinger)->InstallAsService(service_manager);
+    std::make_shared<VI_M>(nv_flinger)->InstallAsService(service_manager);
+    std::make_shared<VI_S>(nv_flinger)->InstallAsService(service_manager);
+    std::make_shared<VI_U>(nv_flinger)->InstallAsService(service_manager);
 }
 
 } // namespace VI

src/core/hle/service/vi/vi.h

@@ -4,6 +4,9 @@
 
 #pragma once
 
+#include <memory>
+#include <boost/optional.hpp>
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
 #include "core/hle/service/service.h"
 
@@ -14,19 +17,26 @@ struct EventType;
 namespace Service {
 namespace VI {
 
-class Module final {
+class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
 public:
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        Interface(std::shared_ptr<Module> module, const char* name,
-                  std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    IApplicationDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    ~IApplicationDisplayService() = default;
 
-        void GetDisplayService(Kernel::HLERequestContext& ctx);
+private:
+    void GetRelayService(Kernel::HLERequestContext& ctx);
+    void GetSystemDisplayService(Kernel::HLERequestContext& ctx);
+    void GetManagerDisplayService(Kernel::HLERequestContext& ctx);
+    void GetIndirectDisplayTransactionService(Kernel::HLERequestContext& ctx);
+    void OpenDisplay(Kernel::HLERequestContext& ctx);
+    void CloseDisplay(Kernel::HLERequestContext& ctx);
+    void SetLayerScalingMode(Kernel::HLERequestContext& ctx);
+    void ListDisplays(Kernel::HLERequestContext& ctx);
+    void OpenLayer(Kernel::HLERequestContext& ctx);
+    void CreateStrayLayer(Kernel::HLERequestContext& ctx);
+    void DestroyStrayLayer(Kernel::HLERequestContext& ctx);
+    void GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx);
 
-    protected:
-        std::shared_ptr<Module> module;
-        std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
-    };
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
 /// Registers all VI services with the specified service manager.

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

@@ -2,13 +2,24 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/vi/vi.h"
 #include "core/hle/service/vi/vi_m.h"
 
 namespace Service {
 namespace VI {
 
-VI_M::VI_M(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : Module::Interface(std::move(module), "vi:m", std::move(nv_flinger)) {
+void VI_M::GetDisplayService(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
+}
+
+VI_M::VI_M(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
+    : ServiceFramework("vi:m"), nv_flinger(std::move(nv_flinger)) {
     static const FunctionInfo functions[] = {
         {2, &VI_M::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

src/core/hle/service/vi/vi_m.h

@@ -4,14 +4,25 @@
 
 #pragma once
 
-#include "core/hle/service/vi/vi.h"
+#include <memory>
+#include "core/hle/service/service.h"
 
 namespace Service {
+namespace NVFlinger {
+class NVFlinger;
+}
+
 namespace VI {
 
-class VI_M final : public Module::Interface {
+class VI_M final : public ServiceFramework<VI_M> {
 public:
-    explicit VI_M(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    VI_M(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    ~VI_M() = default;
+
+private:
+    void GetDisplayService(Kernel::HLERequestContext& ctx);
+
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
 } // namespace VI

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

@@ -2,13 +2,24 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/vi/vi.h"
 #include "core/hle/service/vi/vi_s.h"
 
 namespace Service {
 namespace VI {
 
-VI_S::VI_S(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : Module::Interface(std::move(module), "vi:s", std::move(nv_flinger)) {
+void VI_S::GetDisplayService(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
+}
+
+VI_S::VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
+    : ServiceFramework("vi:s"), nv_flinger(std::move(nv_flinger)) {
     static const FunctionInfo functions[] = {
         {1, &VI_S::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

src/core/hle/service/vi/vi_s.h

@@ -4,14 +4,25 @@
 
 #pragma once
 
-#include "core/hle/service/vi/vi.h"
+#include <memory>
+#include "core/hle/service/service.h"
 
 namespace Service {
+namespace NVFlinger {
+class NVFlinger;
+}
+
 namespace VI {
 
-class VI_S final : public Module::Interface {
+class VI_S final : public ServiceFramework<VI_S> {
 public:
-    explicit VI_S(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    ~VI_S() = default;
+
+private:
+    void GetDisplayService(Kernel::HLERequestContext& ctx);
+
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
 } // namespace VI

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

@@ -2,13 +2,24 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/vi/vi.h"
 #include "core/hle/service/vi/vi_u.h"
 
 namespace Service {
 namespace VI {
 
-VI_U::VI_U(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : Module::Interface(std::move(module), "vi:u", std::move(nv_flinger)) {
+void VI_U::GetDisplayService(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
+}
+
+VI_U::VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
+    : ServiceFramework("vi:u"), nv_flinger(std::move(nv_flinger)) {
     static const FunctionInfo functions[] = {
         {0, &VI_U::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

src/core/hle/service/vi/vi_u.h

@@ -4,14 +4,25 @@
 
 #pragma once
 
-#include "core/hle/service/vi/vi.h"
+#include <memory>
+#include "core/hle/service/service.h"
 
 namespace Service {
+namespace NVFlinger {
+class NVFlinger;
+}
+
 namespace VI {
 
-class VI_U final : public Module::Interface {
+class VI_U final : public ServiceFramework<VI_U> {
 public:
-    explicit VI_U(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    ~VI_U() = default;
+
+private:
+    void GetDisplayService(Kernel::HLERequestContext& ctx);
+
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
 } // namespace VI

src/core/loader/linker.cpp

@@ -84,7 +84,7 @@ void Linker::WriteRelocations(std::vector<u8>& program_image, const std::vector<
             }
             break;
         default:
-            LOG_CRITICAL(Loader, "Unknown relocation type: %d", static_cast<int>(rela.type));
+            LOG_CRITICAL(Loader, "Unknown relocation type: %d", rela.type);
             break;
         }
     }

src/core/memory.cpp

@@ -42,9 +42,6 @@ static void MapPages(PageTable& page_table, VAddr base, u64 size, u8* memory, Pa
     LOG_DEBUG(HW_Memory, "Mapping %p onto %016" PRIX64 "-%016" PRIX64, memory, base * PAGE_SIZE,
               (base + size) * PAGE_SIZE);
 
-    RasterizerFlushVirtualRegion(base << PAGE_BITS, size * PAGE_SIZE,
-                                 FlushMode::FlushAndInvalidate);
-
     VAddr end = base + size;
     while (base != end) {
         ASSERT_MSG(base < PAGE_TABLE_NUM_ENTRIES, "out of range mapping at %016" PRIX64, base);
@@ -296,43 +293,6 @@ u8* GetPhysicalPointer(PAddr address) {
     return target_pointer;
 }
 
-void RasterizerFlushVirtualRegion(VAddr start, u64 size, FlushMode mode) {
-    // Since pages are unmapped on shutdown after video core is shutdown, the renderer may be
-    // null here
-    if (VideoCore::g_renderer == nullptr) {
-        return;
-    }
-
-    VAddr end = start + size;
-
-    auto CheckRegion = [&](VAddr region_start, VAddr region_end) {
-        if (start >= region_end || end <= region_start) {
-            // No overlap with region
-            return;
-        }
-
-        VAddr overlap_start = std::max(start, region_start);
-        VAddr overlap_end = std::min(end, region_end);
-        u64 overlap_size = overlap_end - overlap_start;
-
-        auto* rasterizer = VideoCore::g_renderer->Rasterizer();
-        switch (mode) {
-        case FlushMode::Flush:
-            rasterizer->FlushRegion(overlap_start, overlap_size);
-            break;
-        case FlushMode::Invalidate:
-            rasterizer->InvalidateRegion(overlap_start, overlap_size);
-            break;
-        case FlushMode::FlushAndInvalidate:
-            rasterizer->FlushAndInvalidateRegion(overlap_start, overlap_size);
-            break;
-        }
-    };
-
-    CheckRegion(PROCESS_IMAGE_VADDR, PROCESS_IMAGE_VADDR_END);
-    CheckRegion(HEAP_VADDR, HEAP_VADDR_END);
-}
-
 u8 Read8(const VAddr addr) {
     return Read<u8>(addr);
 }

src/core/memory.h

@@ -36,10 +36,7 @@ enum class PageType : u8 {
     Unmapped,
     /// Page is mapped to regular memory. This is the only type you can get pointers to.
     Memory,
-    /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
-    /// invalidation
-    RasterizerCachedMemory,
-    /// Page is mapped to a I/O region. Writing and reading to this page is handled by functions.
+    /// Page is mapped to a memory hook, which intercepts read and write requests.
     Special,
 };
 
@@ -256,19 +253,4 @@ boost::optional<VAddr> PhysicalToVirtualAddress(PAddr addr);
  */
 u8* GetPhysicalPointer(PAddr address);
 
-enum class FlushMode {
-    /// Write back modified surfaces to RAM
-    Flush,
-    /// Remove region from the cache
-    Invalidate,
-    /// Write back modified surfaces to RAM, and also remove them from the cache
-    FlushAndInvalidate,
-};
-
-/**
- * Flushes and invalidates any externally cached rasterizer resources touching the given virtual
- * address region.
- */
-void RasterizerFlushVirtualRegion(VAddr start, u64 size, FlushMode mode);
-
 } // namespace Memory

src/video_core/CMakeLists.txt

@@ -11,24 +11,13 @@ add_library(video_core STATIC
     gpu.h
     memory_manager.cpp
     memory_manager.h
-    rasterizer_interface.h
     renderer_base.cpp
     renderer_base.h
-    renderer_opengl/gl_rasterizer.cpp
-    renderer_opengl/gl_rasterizer.h
-    renderer_opengl/gl_rasterizer_cache.cpp
-    renderer_opengl/gl_rasterizer_cache.h
     renderer_opengl/gl_resource_manager.h
-    renderer_opengl/gl_shader_decompiler.cpp
-    renderer_opengl/gl_shader_decompiler.h
-    renderer_opengl/gl_shader_gen.cpp
-    renderer_opengl/gl_shader_gen.h
     renderer_opengl/gl_shader_util.cpp
     renderer_opengl/gl_shader_util.h
     renderer_opengl/gl_state.cpp
     renderer_opengl/gl_state.h
-    renderer_opengl/gl_stream_buffer.cpp
-    renderer_opengl/gl_stream_buffer.h
     renderer_opengl/renderer_opengl.cpp
     renderer_opengl/renderer_opengl.h
     utils.h

src/video_core/engines/maxwell_3d.cpp

@@ -153,8 +153,7 @@ void Maxwell3D::ProcessQueryGet() {
         break;
     }
     default:
-        UNIMPLEMENTED_MSG("Query mode %u not implemented",
-                          static_cast<u32>(regs.query.query_get.mode.Value()));
+        UNIMPLEMENTED_MSG("Query mode %u not implemented", regs.query.query_get.mode.Value());
     }
 }
 

src/video_core/engines/maxwell_3d.h

@@ -7,7 +7,6 @@
 #include <array>
 #include <unordered_map>
 #include <vector>
-#include "common/assert.h"
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -32,10 +31,8 @@ public:
     struct Regs {
         static constexpr size_t NUM_REGS = 0xE36;
 
-        static constexpr size_t NumRenderTargets = 8;
         static constexpr size_t NumCBData = 16;
         static constexpr size_t NumVertexArrays = 32;
-        static constexpr size_t NumVertexAttributes = 32;
         static constexpr size_t MaxShaderProgram = 6;
         static constexpr size_t MaxShaderStage = 5;
         // Maximum number of const buffers per shader stage.
@@ -63,171 +60,9 @@ public:
             Fragment = 4,
         };
 
-        enum class VertexSize : u32 {
-            Size_32_32_32_32 = 0x01,
-            Size_32_32_32 = 0x02,
-            Size_16_16_16_16 = 0x03,
-            Size_32_32 = 0x04,
-            Size_16_16_16 = 0x05,
-            Size_8_8_8_8 = 0x0a,
-            Size_16_16 = 0x0f,
-            Size_32 = 0x12,
-            Size_8_8_8 = 0x13,
-            Size_8_8 = 0x18,
-            Size_16 = 0x1b,
-            Size_8 = 0x1d,
-            Size_10_10_10_2 = 0x30,
-            Size_11_11_10 = 0x31,
-        };
-
-        static std::string VertexSizeToString(VertexSize vertex_size) {
-            switch (vertex_size) {
-            case VertexSize::Size_32_32_32_32:
-                return "32_32_32_32";
-            case VertexSize::Size_32_32_32:
-                return "32_32_32";
-            case VertexSize::Size_16_16_16_16:
-                return "16_16_16_16";
-            case VertexSize::Size_32_32:
-                return "32_32";
-            case VertexSize::Size_16_16_16:
-                return "16_16_16";
-            case VertexSize::Size_8_8_8_8:
-                return "8_8_8_8";
-            case VertexSize::Size_16_16:
-                return "16_16";
-            case VertexSize::Size_32:
-                return "32";
-            case VertexSize::Size_8_8_8:
-                return "8_8_8";
-            case VertexSize::Size_8_8:
-                return "8_8";
-            case VertexSize::Size_16:
-                return "16";
-            case VertexSize::Size_8:
-                return "8";
-            case VertexSize::Size_10_10_10_2:
-                return "10_10_10_2";
-            case VertexSize::Size_11_11_10:
-                return "11_11_10";
-            }
-            UNIMPLEMENTED();
-            return {};
-        }
-
-        enum class VertexType : u32 {
-            SignedNorm = 1,
-            UnsignedNorm = 2,
-            SignedInt = 3,
-            UnsignedInt = 4,
-            UnsignedScaled = 5,
-            SignedScaled = 6,
-            Float = 7,
-        };
-
-        static std::string VertexTypeToString(VertexType vertex_type) {
-            switch (vertex_type) {
-            case VertexType::SignedNorm:
-                return "SignedNorm";
-            case VertexType::UnsignedNorm:
-                return "UnsignedNorm";
-            case VertexType::SignedInt:
-                return "SignedInt";
-            case VertexType::UnsignedInt:
-                return "UnsignedInt";
-            case VertexType::UnsignedScaled:
-                return "UnsignedScaled";
-            case VertexType::SignedScaled:
-                return "SignedScaled";
-            case VertexType::Float:
-                return "Float";
-            }
-            UNIMPLEMENTED();
-            return {};
-        }
-
-        enum class PrimitiveTopology : u32 {
-            Points = 0x0,
-            Lines = 0x1,
-            LineLoop = 0x2,
-            LineStrip = 0x3,
-            Triangles = 0x4,
-            TriangleStrip = 0x5,
-            TriangleFan = 0x6,
-            Quads = 0x7,
-            QuadStrip = 0x8,
-            Polygon = 0x9,
-            LinesAdjacency = 0xa,
-            LineStripAdjacency = 0xb,
-            TrianglesAdjacency = 0xc,
-            TriangleStripAdjacency = 0xd,
-            Patches = 0xe,
-        };
-
         union {
             struct {
-                INSERT_PADDING_WORDS(0x200);
-
-                struct {
-                    u32 address_high;
-                    u32 address_low;
-                    u32 horiz;
-                    u32 vert;
-                    u32 format;
-                    u32 block_dimensions;
-                    u32 array_mode;
-                    u32 layer_stride;
-                    u32 base_layer;
-                    INSERT_PADDING_WORDS(7);
-
-                    GPUVAddr Address() const {
-                        return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
-                                                     address_low);
-                    }
-                } rt[NumRenderTargets];
-
-                INSERT_PADDING_WORDS(0xDD);
-
-                struct {
-                    u32 first;
-                    u32 count;
-                } vertex_buffer;
-
-                INSERT_PADDING_WORDS(0x99);
-
-                struct {
-                    u32 address_high;
-                    u32 address_low;
-                    u32 format;
-                    u32 block_dimensions;
-                    u32 layer_stride;
-
-                    GPUVAddr Address() const {
-                        return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
-                                                     address_low);
-                    }
-                } zeta;
-
-                INSERT_PADDING_WORDS(0x5B);
-
-                union {
-                    BitField<0, 5, u32> buffer;
-                    BitField<6, 1, u32> constant;
-                    BitField<7, 14, u32> offset;
-                    BitField<21, 6, VertexSize> size;
-                    BitField<27, 3, VertexType> type;
-                    BitField<31, 1, u32> bgra;
-                } vertex_attrib_format[NumVertexAttributes];
-
-                INSERT_PADDING_WORDS(0xF);
-
-                struct {
-                    union {
-                        BitField<0, 4, u32> count;
-                    };
-                } rt_control;
-
-                INSERT_PADDING_WORDS(0xCF);
+                INSERT_PADDING_WORDS(0x557);
 
                 struct {
                     u32 tsc_address_high;
@@ -265,15 +100,10 @@ public:
                     }
                 } code_address;
                 INSERT_PADDING_WORDS(1);
-
                 struct {
                     u32 vertex_end_gl;
-                    union {
-                        u32 vertex_begin_gl;
-                        BitField<0, 16, PrimitiveTopology> topology;
-                    };
+                    u32 vertex_begin_gl;
                 } draw;
-
                 INSERT_PADDING_WORDS(0x139);
                 struct {
                     u32 query_address_high;
@@ -461,11 +291,6 @@ private:
     static_assert(offsetof(Maxwell3D::Regs, field_name) == position * 4,                           \
                   "Field " #field_name " has invalid position")
 
-ASSERT_REG_POSITION(rt, 0x200);
-ASSERT_REG_POSITION(vertex_buffer, 0x35D);
-ASSERT_REG_POSITION(zeta, 0x3F8);
-ASSERT_REG_POSITION(vertex_attrib_format[0], 0x458);
-ASSERT_REG_POSITION(rt_control, 0x487);
 ASSERT_REG_POSITION(tsc, 0x557);
 ASSERT_REG_POSITION(tic, 0x55D);
 ASSERT_REG_POSITION(code_address, 0x582);

src/video_core/gpu.h

@@ -8,42 +8,10 @@
 #include <unordered_map>
 #include <vector>
 #include "common/common_types.h"
-#include "core/hle/service/nvflinger/buffer_queue.h"
 #include "video_core/memory_manager.h"
 
 namespace Tegra {
 
-/**
- * Struct describing framebuffer configuration
- */
-struct FramebufferConfig {
-    enum class PixelFormat : u32 {
-        ABGR8 = 1,
-    };
-
-    /**
-     * Returns the number of bytes per pixel.
-     */
-    static u32 BytesPerPixel(PixelFormat format) {
-        switch (format) {
-        case PixelFormat::ABGR8:
-            return 4;
-        }
-
-        UNREACHABLE();
-    }
-
-    VAddr address;
-    u32 offset;
-    u32 width;
-    u32 height;
-    u32 stride;
-    PixelFormat pixel_format;
-
-    using TransformFlags = Service::NVFlinger::BufferQueue::BufferTransformFlags;
-    TransformFlags transform_flags;
-};
-
 namespace Engines {
 class Fermi2D;
 class Maxwell3D;
@@ -68,10 +36,6 @@ public:
 
     std::unique_ptr<MemoryManager> memory_manager;
 
-    Engines::Maxwell3D& Maxwell3D() {
-        return *maxwell_3d;
-    }
-
 private:
     static constexpr u32 InvalidGraphMacroEntry = 0xFFFFFFFF;
 

src/video_core/rasterizer_interface.h

@@ -1,63 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "video_core/gpu.h"
-
-struct ScreenInfo;
-
-namespace VideoCore {
-
-class RasterizerInterface {
-public:
-    virtual ~RasterizerInterface() {}
-
-    /// Draw the current batch of triangles
-    virtual void DrawTriangles() = 0;
-
-    /// Notify rasterizer that the specified Maxwell register has been changed
-    virtual void NotifyMaxwellRegisterChanged(u32 id) = 0;
-
-    /// Notify rasterizer that all caches should be flushed to 3DS memory
-    virtual void FlushAll() = 0;
-
-    /// Notify rasterizer that any caches of the specified region should be flushed to 3DS memory
-    virtual void FlushRegion(VAddr addr, u64 size) = 0;
-
-    /// Notify rasterizer that any caches of the specified region should be invalidated
-    virtual void InvalidateRegion(VAddr addr, u64 size) = 0;
-
-    /// Notify rasterizer that any caches of the specified region should be flushed to 3DS memory
-    /// and invalidated
-    virtual void FlushAndInvalidateRegion(VAddr addr, u64 size) = 0;
-
-    /// Attempt to use a faster method to perform a display transfer with is_texture_copy = 0
-    virtual bool AccelerateDisplayTransfer(const void* config) {
-        return false;
-    }
-
-    /// Attempt to use a faster method to perform a display transfer with is_texture_copy = 1
-    virtual bool AccelerateTextureCopy(const void* config) {
-        return false;
-    }
-
-    /// Attempt to use a faster method to fill a region
-    virtual bool AccelerateFill(const void* config) {
-        return false;
-    }
-
-    /// Attempt to use a faster method to display the framebuffer to screen
-    virtual bool AccelerateDisplay(const Tegra::FramebufferConfig& framebuffer,
-                                   VAddr framebuffer_addr, u32 pixel_stride,
-                                   ScreenInfo& screen_info) {
-        return false;
-    }
-
-    virtual bool AccelerateDrawBatch(bool is_indexed) {
-        return false;
-    }
-};
-} // namespace VideoCore

src/video_core/renderer_base.cpp

@@ -5,11 +5,6 @@
 #include <atomic>
 #include <memory>
 #include "video_core/renderer_base.h"
-#include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/video_core.h"
 
-void RendererBase::RefreshRasterizerSetting() {
-    if (rasterizer == nullptr) {
-        rasterizer = std::make_unique<RasterizerOpenGL>();
-    }
-}
+void RendererBase::RefreshRasterizerSetting() {}

src/video_core/renderer_base.h

@@ -8,8 +8,6 @@
 #include <boost/optional.hpp>
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "video_core/gpu.h"
-#include "video_core/rasterizer_interface.h"
 
 class EmuWindow;
 
@@ -18,10 +16,40 @@ public:
     /// Used to reference a framebuffer
     enum kFramebuffer { kFramebuffer_VirtualXFB = 0, kFramebuffer_EFB, kFramebuffer_Texture };
 
+    /**
+     * Struct describing framebuffer metadata
+     * TODO(bunnei): This struct belongs in the GPU code, but we don't have a good place for it yet.
+     */
+    struct FramebufferInfo {
+        enum class PixelFormat : u32 {
+            ABGR8 = 1,
+        };
+
+        /**
+         * Returns the number of bytes per pixel.
+         */
+        static u32 BytesPerPixel(PixelFormat format) {
+            switch (format) {
+            case PixelFormat::ABGR8:
+                return 4;
+            }
+
+            UNREACHABLE();
+        }
+
+        VAddr address;
+        u32 offset;
+        u32 width;
+        u32 height;
+        u32 stride;
+        PixelFormat pixel_format;
+        bool flip_vertical;
+    };
+
     virtual ~RendererBase() {}
 
     /// Swap buffers (render frame)
-    virtual void SwapBuffers(boost::optional<const Tegra::FramebufferConfig&> framebuffer) = 0;
+    virtual void SwapBuffers(boost::optional<const FramebufferInfo&> framebuffer_info) = 0;
 
     /**
      * Set the emulator window to use for renderer
@@ -46,16 +74,12 @@ public:
         return m_current_frame;
     }
 
-    VideoCore::RasterizerInterface* Rasterizer() const {
-        return rasterizer.get();
-    }
-
     void RefreshRasterizerSetting();
 
 protected:
-    std::unique_ptr<VideoCore::RasterizerInterface> rasterizer;
     f32 m_current_fps = 0.0f; ///< Current framerate, should be set by the renderer
     int m_current_frame = 0;  ///< Current frame, should be set by the renderer
 
 private:
+    bool opengl_rasterizer_active = false;
 };

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -1,349 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <memory>
-#include <string>
-#include <tuple>
-#include <utility>
-#include <glad/glad.h>
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/math_util.h"
-#include "common/microprofile.h"
-#include "common/scope_exit.h"
-#include "common/vector_math.h"
-#include "core/settings.h"
-#include "video_core/renderer_opengl/gl_rasterizer.h"
-#include "video_core/renderer_opengl/gl_shader_gen.h"
-#include "video_core/renderer_opengl/renderer_opengl.h"
-
-using PixelFormat = SurfaceParams::PixelFormat;
-using SurfaceType = SurfaceParams::SurfaceType;
-
-MICROPROFILE_DEFINE(OpenGL_VAO, "OpenGL", "Vertex Array Setup", MP_RGB(128, 128, 192));
-MICROPROFILE_DEFINE(OpenGL_VS, "OpenGL", "Vertex Shader Setup", MP_RGB(128, 128, 192));
-MICROPROFILE_DEFINE(OpenGL_FS, "OpenGL", "Fragment Shader Setup", MP_RGB(128, 128, 192));
-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));
-
-enum class UniformBindings : GLuint { Common, VS, FS };
-
-static void SetShaderUniformBlockBinding(GLuint shader, const char* name, UniformBindings binding,
-                                         size_t expected_size) {
-    GLuint ub_index = glGetUniformBlockIndex(shader, name);
-    if (ub_index != GL_INVALID_INDEX) {
-        GLint ub_size = 0;
-        glGetActiveUniformBlockiv(shader, ub_index, GL_UNIFORM_BLOCK_DATA_SIZE, &ub_size);
-        ASSERT_MSG(ub_size == expected_size,
-                   "Uniform block size did not match! Got %d, expected %zu",
-                   static_cast<int>(ub_size), expected_size);
-        glUniformBlockBinding(shader, ub_index, static_cast<GLuint>(binding));
-    }
-}
-
-static void SetShaderUniformBlockBindings(GLuint shader) {
-    SetShaderUniformBlockBinding(shader, "shader_data", UniformBindings::Common,
-                                 sizeof(RasterizerOpenGL::UniformData));
-    SetShaderUniformBlockBinding(shader, "vs_config", UniformBindings::VS,
-                                 sizeof(RasterizerOpenGL::VSUniformData));
-    SetShaderUniformBlockBinding(shader, "fs_config", UniformBindings::FS,
-                                 sizeof(RasterizerOpenGL::FSUniformData));
-}
-
-RasterizerOpenGL::RasterizerOpenGL() {
-    shader_dirty = true;
-
-    has_ARB_buffer_storage = false;
-    has_ARB_direct_state_access = false;
-    has_ARB_separate_shader_objects = false;
-    has_ARB_vertex_attrib_binding = false;
-
-    GLint ext_num;
-    glGetIntegerv(GL_NUM_EXTENSIONS, &ext_num);
-    for (GLint i = 0; i < ext_num; i++) {
-        std::string extension{reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i))};
-
-        if (extension == "GL_ARB_buffer_storage") {
-            has_ARB_buffer_storage = true;
-        } else if (extension == "GL_ARB_direct_state_access") {
-            has_ARB_direct_state_access = true;
-        } else if (extension == "GL_ARB_separate_shader_objects") {
-            has_ARB_separate_shader_objects = true;
-        } else if (extension == "GL_ARB_vertex_attrib_binding") {
-            has_ARB_vertex_attrib_binding = true;
-        }
-    }
-
-    // Clipping plane 0 is always enabled for PICA fixed clip plane z <= 0
-    state.clip_distance[0] = true;
-
-    // Generate VBO, VAO and UBO
-    vertex_buffer = OGLStreamBuffer::MakeBuffer(GLAD_GL_ARB_buffer_storage, GL_ARRAY_BUFFER);
-    vertex_buffer->Create(VERTEX_BUFFER_SIZE, VERTEX_BUFFER_SIZE / 2);
-    sw_vao.Create();
-    uniform_buffer.Create();
-
-    state.draw.vertex_array = sw_vao.handle;
-    state.draw.vertex_buffer = vertex_buffer->GetHandle();
-    state.draw.uniform_buffer = uniform_buffer.handle;
-    state.Apply();
-
-    glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformData), nullptr, GL_STATIC_DRAW);
-    glBindBufferBase(GL_UNIFORM_BUFFER, 0, uniform_buffer.handle);
-
-    uniform_block_data.dirty = true;
-
-    // Create render framebuffer
-    framebuffer.Create();
-
-    if (has_ARB_separate_shader_objects) {
-        hw_vao.Create();
-        hw_vao_enabled_attributes.fill(false);
-
-        stream_buffer = OGLStreamBuffer::MakeBuffer(has_ARB_buffer_storage, GL_ARRAY_BUFFER);
-        stream_buffer->Create(STREAM_BUFFER_SIZE, STREAM_BUFFER_SIZE / 2);
-        state.draw.vertex_buffer = stream_buffer->GetHandle();
-
-        pipeline.Create();
-        state.draw.program_pipeline = pipeline.handle;
-        state.draw.shader_program = 0;
-        state.draw.vertex_array = hw_vao.handle;
-        state.Apply();
-
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, stream_buffer->GetHandle());
-
-        vs_uniform_buffer.Create();
-        glBindBuffer(GL_UNIFORM_BUFFER, vs_uniform_buffer.handle);
-        glBufferData(GL_UNIFORM_BUFFER, sizeof(VSUniformData), nullptr, GL_STREAM_COPY);
-        glBindBufferBase(GL_UNIFORM_BUFFER, 1, vs_uniform_buffer.handle);
-    } else {
-        ASSERT_MSG(false, "Unimplemented");
-    }
-
-    accelerate_draw = AccelDraw::Disabled;
-
-    glEnable(GL_BLEND);
-
-    LOG_WARNING(HW_GPU, "Sync fixed function OpenGL state here when ready");
-}
-
-RasterizerOpenGL::~RasterizerOpenGL() {
-    if (stream_buffer != nullptr) {
-        state.draw.vertex_buffer = stream_buffer->GetHandle();
-        state.Apply();
-        stream_buffer->Release();
-    }
-}
-
-static constexpr std::array<GLenum, 4> vs_attrib_types{
-    GL_BYTE,          // VertexAttributeFormat::BYTE
-    GL_UNSIGNED_BYTE, // VertexAttributeFormat::UBYTE
-    GL_SHORT,         // VertexAttributeFormat::SHORT
-    GL_FLOAT          // VertexAttributeFormat::FLOAT
-};
-
-void RasterizerOpenGL::AnalyzeVertexArray(bool is_indexed) {
-    UNIMPLEMENTED();
-}
-
-void RasterizerOpenGL::SetupVertexArray(u8* array_ptr, GLintptr buffer_offset) {
-    MICROPROFILE_SCOPE(OpenGL_VAO);
-    UNIMPLEMENTED();
-}
-
-void RasterizerOpenGL::SetupVertexShader(VSUniformData* ub_ptr, GLintptr buffer_offset) {
-    MICROPROFILE_SCOPE(OpenGL_VS);
-    UNIMPLEMENTED();
-}
-
-void RasterizerOpenGL::SetupFragmentShader(FSUniformData* ub_ptr, GLintptr buffer_offset) {
-    MICROPROFILE_SCOPE(OpenGL_FS);
-    ASSERT_MSG(false, "Unimplemented");
-}
-
-bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
-    if (!has_ARB_separate_shader_objects) {
-        ASSERT_MSG(false, "Unimplemented");
-        return false;
-    }
-
-    accelerate_draw = is_indexed ? AccelDraw::Indexed : AccelDraw::Arrays;
-    DrawTriangles();
-
-    return true;
-}
-
-void RasterizerOpenGL::DrawTriangles() {
-    MICROPROFILE_SCOPE(OpenGL_Drawing);
-    UNIMPLEMENTED();
-}
-
-void RasterizerOpenGL::NotifyMaxwellRegisterChanged(u32 id) {}
-
-void RasterizerOpenGL::FlushAll() {
-    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-    res_cache.FlushAll();
-}
-
-void RasterizerOpenGL::FlushRegion(VAddr addr, u64 size) {
-    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-    res_cache.FlushRegion(addr, size);
-}
-
-void RasterizerOpenGL::InvalidateRegion(VAddr addr, u64 size) {
-    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-    res_cache.InvalidateRegion(addr, size, nullptr);
-}
-
-void RasterizerOpenGL::FlushAndInvalidateRegion(VAddr addr, u64 size) {
-    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-    res_cache.FlushRegion(addr, size);
-    res_cache.InvalidateRegion(addr, size, nullptr);
-}
-
-bool RasterizerOpenGL::AccelerateDisplayTransfer(const void* config) {
-    MICROPROFILE_SCOPE(OpenGL_Blits);
-    ASSERT_MSG(false, "Unimplemented");
-    return true;
-}
-
-bool RasterizerOpenGL::AccelerateTextureCopy(const void* config) {
-    ASSERT_MSG(false, "Unimplemented");
-    return true;
-}
-
-bool RasterizerOpenGL::AccelerateFill(const void* config) {
-    ASSERT_MSG(false, "Unimplemented");
-    return true;
-}
-
-bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& framebuffer,
-                                         VAddr framebuffer_addr, u32 pixel_stride,
-                                         ScreenInfo& screen_info) {
-    if (framebuffer_addr == 0) {
-        return false;
-    }
-    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-
-    SurfaceParams src_params;
-    src_params.addr = framebuffer_addr;
-    src_params.width = std::min(framebuffer.width, pixel_stride);
-    src_params.height = framebuffer.height;
-    src_params.stride = pixel_stride;
-    src_params.is_tiled = false;
-    src_params.pixel_format =
-        SurfaceParams::PixelFormatFromGPUPixelFormat(framebuffer.pixel_format);
-    src_params.UpdateParams();
-
-    MathUtil::Rectangle<u32> src_rect;
-    Surface src_surface;
-    std::tie(src_surface, src_rect) =
-        res_cache.GetSurfaceSubRect(src_params, ScaleMatch::Ignore, true);
-
-    if (src_surface == nullptr) {
-        return false;
-    }
-
-    u32 scaled_width = src_surface->GetScaledWidth();
-    u32 scaled_height = src_surface->GetScaledHeight();
-
-    screen_info.display_texcoords = MathUtil::Rectangle<float>(
-        (float)src_rect.bottom / (float)scaled_height, (float)src_rect.left / (float)scaled_width,
-        (float)src_rect.top / (float)scaled_height, (float)src_rect.right / (float)scaled_width);
-
-    screen_info.display_texture = src_surface->texture.handle;
-
-    return true;
-}
-
-void RasterizerOpenGL::SetShader() {
-    // TODO(bunnei): The below sets up a static test shader for passing untransformed vertices to
-    // OpenGL for rendering. This should be removed/replaced when we start emulating Maxwell
-    // shaders.
-
-    static constexpr char vertex_shader[] = R"(
-#version 150 core
-
-in vec2 vert_position;
-in vec2 vert_tex_coord;
-out vec2 frag_tex_coord;
-
-void main() {
-    // Multiply input position by the rotscale part of the matrix and then manually translate by
-    // the last column. This is equivalent to using a full 3x3 matrix and expanding the vector
-    // to `vec3(vert_position.xy, 1.0)`
-    gl_Position = vec4(mat2(mat3x2(0.0015625f, 0.0, 0.0, -0.0027778, -1.0, 1.0)) * vert_position + mat3x2(0.0015625f, 0.0, 0.0, -0.0027778, -1.0, 1.0)[2], 0.0, 1.0);
-    frag_tex_coord = vert_tex_coord;
-}
-)";
-
-    static constexpr char fragment_shader[] = R"(
-#version 150 core
-
-in vec2 frag_tex_coord;
-out vec4 color;
-
-uniform sampler2D color_texture;
-
-void main() {
-    color = vec4(1.0, 0.0, 1.0, 0.0);
-}
-)";
-
-    if (current_shader) {
-        return;
-    }
-
-    LOG_ERROR(HW_GPU, "Emulated shaders are not supported! Using a passthrough shader.");
-
-    current_shader = &test_shader;
-    if (has_ARB_separate_shader_objects) {
-        test_shader.shader.Create(vertex_shader, nullptr, fragment_shader, {}, true);
-        glActiveShaderProgram(pipeline.handle, test_shader.shader.handle);
-    } else {
-        ASSERT_MSG(false, "Unimplemented");
-    }
-
-    state.draw.shader_program = test_shader.shader.handle;
-    state.Apply();
-
-    if (has_ARB_separate_shader_objects) {
-        state.draw.shader_program = 0;
-        state.Apply();
-    }
-}
-
-void RasterizerOpenGL::SyncClipEnabled() {
-    ASSERT_MSG(false, "Unimplemented");
-}
-
-void RasterizerOpenGL::SyncClipCoef() {
-    ASSERT_MSG(false, "Unimplemented");
-}
-
-void RasterizerOpenGL::SyncCullMode() {
-    ASSERT_MSG(false, "Unimplemented");
-}
-
-void RasterizerOpenGL::SyncDepthScale() {
-    ASSERT_MSG(false, "Unimplemented");
-}
-
-void RasterizerOpenGL::SyncDepthOffset() {
-    ASSERT_MSG(false, "Unimplemented");
-}
-
-void RasterizerOpenGL::SyncBlendEnabled() {
-    ASSERT_MSG(false, "Unimplemented");
-}
-
-void RasterizerOpenGL::SyncBlendFuncs() {
-    ASSERT_MSG(false, "Unimplemented");
-}
-
-void RasterizerOpenGL::SyncBlendColor() {
-    ASSERT_MSG(false, "Unimplemented");
-}

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -1,172 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <cstddef>
-#include <cstring>
-#include <memory>
-#include <unordered_map>
-#include <vector>
-#include <glad/glad.h>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "common/hash.h"
-#include "common/vector_math.h"
-#include "video_core/rasterizer_interface.h"
-#include "video_core/renderer_opengl/gl_rasterizer_cache.h"
-#include "video_core/renderer_opengl/gl_resource_manager.h"
-#include "video_core/renderer_opengl/gl_shader_gen.h"
-#include "video_core/renderer_opengl/gl_state.h"
-#include "video_core/renderer_opengl/gl_stream_buffer.h"
-
-struct ScreenInfo;
-
-class RasterizerOpenGL : public VideoCore::RasterizerInterface {
-public:
-    RasterizerOpenGL();
-    ~RasterizerOpenGL() override;
-
-    void DrawTriangles() override;
-    void NotifyMaxwellRegisterChanged(u32 id) override;
-    void FlushAll() override;
-    void FlushRegion(VAddr addr, u64 size) override;
-    void InvalidateRegion(VAddr addr, u64 size) override;
-    void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
-    bool AccelerateDisplayTransfer(const void* config) override;
-    bool AccelerateTextureCopy(const void* config) override;
-    bool AccelerateFill(const void* config) override;
-    bool AccelerateDisplay(const Tegra::FramebufferConfig& framebuffer, VAddr framebuffer_addr,
-                           u32 pixel_stride, ScreenInfo& screen_info) override;
-    bool AccelerateDrawBatch(bool is_indexed) override;
-
-    /// OpenGL shader generated for a given Maxwell register state
-    struct MaxwellShader {
-        /// OpenGL shader resource
-        OGLShader shader;
-    };
-
-    struct VertexShader {
-        OGLShader shader;
-    };
-
-    struct FragmentShader {
-        OGLShader shader;
-    };
-
-    /// Uniform structure for the Uniform Buffer Object, all vectors must be 16-byte aligned
-    // NOTE: Always keep a vec4 at the end. The GL spec is not clear wether the alignment at
-    //       the end of a uniform block is included in UNIFORM_BLOCK_DATA_SIZE or not.
-    //       Not following that rule will cause problems on some AMD drivers.
-    struct UniformData {};
-
-    // static_assert(
-    //    sizeof(UniformData) == 0x460,
-    //    "The size of the UniformData structure has changed, update the structure in the shader");
-    static_assert(sizeof(UniformData) < 16384,
-                  "UniformData structure must be less than 16kb as per the OpenGL spec");
-
-    struct VSUniformData {};
-    // static_assert(
-    //    sizeof(VSUniformData) == 1856,
-    //    "The size of the VSUniformData structure has changed, update the structure in the
-    //    shader");
-    static_assert(sizeof(VSUniformData) < 16384,
-                  "VSUniformData structure must be less than 16kb as per the OpenGL spec");
-
-    struct FSUniformData {};
-    // static_assert(
-    //    sizeof(FSUniformData) == 1856,
-    //    "The size of the FSUniformData structure has changed, update the structure in the
-    //    shader");
-    static_assert(sizeof(FSUniformData) < 16384,
-                  "FSUniformData structure must be less than 16kb as per the OpenGL spec");
-
-private:
-    struct SamplerInfo {};
-
-    /// Syncs the clip enabled status to match the guest state
-    void SyncClipEnabled();
-
-    /// Syncs the clip coefficients to match the guest state
-    void SyncClipCoef();
-
-    /// Sets the OpenGL shader in accordance with the current guest state
-    void SetShader();
-
-    /// Syncs the cull mode to match the guest state
-    void SyncCullMode();
-
-    /// Syncs the depth scale to match the guest state
-    void SyncDepthScale();
-
-    /// Syncs the depth offset to match the guest state
-    void SyncDepthOffset();
-
-    /// Syncs the blend enabled status to match the guest state
-    void SyncBlendEnabled();
-
-    /// Syncs the blend functions to match the guest state
-    void SyncBlendFuncs();
-
-    /// Syncs the blend color to match the guest state
-    void SyncBlendColor();
-
-    bool has_ARB_buffer_storage;
-    bool has_ARB_direct_state_access;
-    bool has_ARB_separate_shader_objects;
-    bool has_ARB_vertex_attrib_binding;
-
-    OpenGLState state;
-
-    RasterizerCacheOpenGL res_cache;
-
-    /// Shader used for test renderering - to be removed once we have emulated shaders
-    MaxwellShader test_shader{};
-
-    const MaxwellShader* current_shader{};
-    bool shader_dirty{};
-
-    struct {
-        UniformData data;
-        bool dirty;
-    } uniform_block_data = {};
-
-    OGLPipeline pipeline;
-    OGLVertexArray sw_vao;
-    OGLVertexArray hw_vao;
-    std::array<bool, 16> hw_vao_enabled_attributes;
-
-    std::array<SamplerInfo, 3> texture_samplers;
-    static constexpr size_t VERTEX_BUFFER_SIZE = 128 * 1024 * 1024;
-    std::unique_ptr<OGLStreamBuffer> vertex_buffer;
-    OGLBuffer uniform_buffer;
-    OGLFramebuffer framebuffer;
-
-    static constexpr size_t STREAM_BUFFER_SIZE = 4 * 1024 * 1024;
-    std::unique_ptr<OGLStreamBuffer> stream_buffer;
-
-    GLsizeiptr vs_input_size;
-
-    void AnalyzeVertexArray(bool is_indexed);
-    void SetupVertexArray(u8* array_ptr, GLintptr buffer_offset);
-
-    OGLBuffer vs_uniform_buffer;
-    std::unordered_map<GLShader::MaxwellVSConfig, VertexShader*> vs_shader_map;
-    std::unordered_map<std::string, VertexShader> vs_shader_cache;
-    OGLShader vs_default_shader;
-
-    void SetupVertexShader(VSUniformData* ub_ptr, GLintptr buffer_offset);
-
-    OGLBuffer fs_uniform_buffer;
-    std::unordered_map<GLShader::MaxwellFSConfig, FragmentShader*> fs_shader_map;
-    std::unordered_map<std::string, FragmentShader> fs_shader_cache;
-    OGLShader fs_default_shader;
-
-    void SetupFragmentShader(FSUniformData* ub_ptr, GLintptr buffer_offset);
-
-    enum class AccelDraw { Disabled, Arrays, Indexed };
-    AccelDraw accelerate_draw;
-};

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -1,360 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <set>
-#include <tuple>
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
-#endif
-#include <boost/icl/interval_map.hpp>
-#include <boost/icl/interval_set.hpp>
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-#include <glad/glad.h>
-#include "common/assert.h"
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/math_util.h"
-#include "video_core/gpu.h"
-#include "video_core/renderer_opengl/gl_resource_manager.h"
-
-struct CachedSurface;
-using Surface = std::shared_ptr<CachedSurface>;
-using SurfaceSet = std::set<Surface>;
-
-using SurfaceRegions = boost::icl::interval_set<VAddr>;
-using SurfaceMap = boost::icl::interval_map<VAddr, Surface>;
-using SurfaceCache = boost::icl::interval_map<VAddr, SurfaceSet>;
-
-using SurfaceInterval = SurfaceCache::interval_type;
-static_assert(std::is_same<SurfaceRegions::interval_type, SurfaceCache::interval_type>() &&
-                  std::is_same<SurfaceMap::interval_type, SurfaceCache::interval_type>(),
-              "incorrect interval types");
-
-using SurfaceRect_Tuple = std::tuple<Surface, MathUtil::Rectangle<u32>>;
-using SurfaceSurfaceRect_Tuple = std::tuple<Surface, Surface, MathUtil::Rectangle<u32>>;
-
-using PageMap = boost::icl::interval_map<u32, int>;
-
-enum class ScaleMatch {
-    Exact,   // only accept same res scale
-    Upscale, // only allow higher scale than params
-    Ignore   // accept every scaled res
-};
-
-struct SurfaceParams {
-    enum class PixelFormat {
-        // First 5 formats are shared between textures and color buffers
-        RGBA8 = 0,
-        RGB8 = 1,
-        RGB5A1 = 2,
-        RGB565 = 3,
-        RGBA4 = 4,
-
-        // Texture-only formats
-        IA8 = 5,
-        RG8 = 6,
-        I8 = 7,
-        A8 = 8,
-        IA4 = 9,
-        I4 = 10,
-        A4 = 11,
-        ETC1 = 12,
-        ETC1A4 = 13,
-
-        // Depth buffer-only formats
-        D16 = 14,
-        // gap
-        D24 = 16,
-        D24S8 = 17,
-
-        Invalid = 255,
-    };
-
-    enum class SurfaceType {
-        Color = 0,
-        Texture = 1,
-        Depth = 2,
-        DepthStencil = 3,
-        Fill = 4,
-        Invalid = 5
-    };
-
-    static constexpr unsigned int GetFormatBpp(PixelFormat format) {
-        constexpr std::array<unsigned int, 18> bpp_table = {
-            32, // RGBA8
-            24, // RGB8
-            16, // RGB5A1
-            16, // RGB565
-            16, // RGBA4
-            16, // IA8
-            16, // RG8
-            8,  // I8
-            8,  // A8
-            8,  // IA4
-            4,  // I4
-            4,  // A4
-            4,  // ETC1
-            8,  // ETC1A4
-            16, // D16
-            0,
-            24, // D24
-            32, // D24S8
-        };
-
-        assert(static_cast<size_t>(format) < bpp_table.size());
-        return bpp_table[static_cast<size_t>(format)];
-    }
-    unsigned int GetFormatBpp() const {
-        return GetFormatBpp(pixel_format);
-    }
-
-    static PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format) {
-        switch (format) {
-        case Tegra::FramebufferConfig::PixelFormat::ABGR8:
-            return PixelFormat::RGBA8;
-        default:
-            UNREACHABLE();
-        }
-    }
-
-    static bool CheckFormatsBlittable(PixelFormat pixel_format_a, PixelFormat pixel_format_b) {
-        SurfaceType a_type = GetFormatType(pixel_format_a);
-        SurfaceType b_type = GetFormatType(pixel_format_b);
-
-        if ((a_type == SurfaceType::Color || a_type == SurfaceType::Texture) &&
-            (b_type == SurfaceType::Color || b_type == SurfaceType::Texture)) {
-            return true;
-        }
-
-        if (a_type == SurfaceType::Depth && b_type == SurfaceType::Depth) {
-            return true;
-        }
-
-        if (a_type == SurfaceType::DepthStencil && b_type == SurfaceType::DepthStencil) {
-            return true;
-        }
-
-        return false;
-    }
-
-    static constexpr SurfaceType GetFormatType(PixelFormat pixel_format) {
-        if ((unsigned int)pixel_format < 5) {
-            return SurfaceType::Color;
-        }
-
-        if ((unsigned int)pixel_format < 14) {
-            return SurfaceType::Texture;
-        }
-
-        if (pixel_format == PixelFormat::D16 || pixel_format == PixelFormat::D24) {
-            return SurfaceType::Depth;
-        }
-
-        if (pixel_format == PixelFormat::D24S8) {
-            return SurfaceType::DepthStencil;
-        }
-
-        return SurfaceType::Invalid;
-    }
-
-    /// Update the params "size", "end" and "type" from the already set "addr", "width", "height"
-    /// and "pixel_format"
-    void UpdateParams() {
-        if (stride == 0) {
-            stride = width;
-        }
-        type = GetFormatType(pixel_format);
-        size = !is_tiled ? BytesInPixels(stride * (height - 1) + width)
-                         : BytesInPixels(stride * 8 * (height / 8 - 1) + width * 8);
-        end = addr + size;
-    }
-
-    SurfaceInterval GetInterval() const {
-        return SurfaceInterval::right_open(addr, end);
-    }
-
-    // Returns the outer rectangle containing "interval"
-    SurfaceParams FromInterval(SurfaceInterval interval) const;
-
-    SurfaceInterval GetSubRectInterval(MathUtil::Rectangle<u32> unscaled_rect) const;
-
-    // Returns the region of the biggest valid rectange within interval
-    SurfaceInterval GetCopyableInterval(const Surface& src_surface) const;
-
-    u32 GetScaledWidth() const {
-        return width * res_scale;
-    }
-
-    u32 GetScaledHeight() const {
-        return height * res_scale;
-    }
-
-    MathUtil::Rectangle<u32> GetRect() const {
-        return {0, height, width, 0};
-    }
-
-    MathUtil::Rectangle<u32> GetScaledRect() const {
-        return {0, GetScaledHeight(), GetScaledWidth(), 0};
-    }
-
-    u64 PixelsInBytes(u64 size) const {
-        return size * CHAR_BIT / GetFormatBpp(pixel_format);
-    }
-
-    u64 BytesInPixels(u64 pixels) const {
-        return pixels * GetFormatBpp(pixel_format) / CHAR_BIT;
-    }
-
-    bool ExactMatch(const SurfaceParams& other_surface) const;
-    bool CanSubRect(const SurfaceParams& sub_surface) const;
-    bool CanExpand(const SurfaceParams& expanded_surface) const;
-    bool CanTexCopy(const SurfaceParams& texcopy_params) const;
-
-    MathUtil::Rectangle<u32> GetSubRect(const SurfaceParams& sub_surface) const;
-    MathUtil::Rectangle<u32> GetScaledSubRect(const SurfaceParams& sub_surface) const;
-
-    VAddr addr = 0;
-    VAddr end = 0;
-    u64 size = 0;
-
-    u32 width = 0;
-    u32 height = 0;
-    u32 stride = 0;
-    u16 res_scale = 1;
-
-    bool is_tiled = false;
-    PixelFormat pixel_format = PixelFormat::Invalid;
-    SurfaceType type = SurfaceType::Invalid;
-};
-
-struct CachedSurface : SurfaceParams {
-    bool CanFill(const SurfaceParams& dest_surface, SurfaceInterval fill_interval) const;
-    bool CanCopy(const SurfaceParams& dest_surface, SurfaceInterval copy_interval) const;
-
-    bool IsRegionValid(SurfaceInterval interval) const {
-        return (invalid_regions.find(interval) == invalid_regions.end());
-    }
-
-    bool IsSurfaceFullyInvalid() const {
-        return (invalid_regions & GetInterval()) == SurfaceRegions(GetInterval());
-    }
-
-    bool registered = false;
-    SurfaceRegions invalid_regions;
-
-    u64 fill_size = 0; /// Number of bytes to read from fill_data
-    std::array<u8, 4> fill_data;
-
-    OGLTexture texture;
-
-    static constexpr unsigned int GetGLBytesPerPixel(PixelFormat format) {
-        // OpenGL needs 4 bpp alignment for D24 since using GL_UNSIGNED_INT as type
-        return format == PixelFormat::Invalid
-                   ? 0
-                   : (format == PixelFormat::D24 || GetFormatType(format) == SurfaceType::Texture)
-                         ? 4
-                         : SurfaceParams::GetFormatBpp(format) / 8;
-    }
-
-    std::unique_ptr<u8[]> gl_buffer;
-    size_t gl_buffer_size = 0;
-
-    // Read/Write data in Switch memory to/from gl_buffer
-    void LoadGLBuffer(VAddr load_start, VAddr load_end);
-    void FlushGLBuffer(VAddr flush_start, VAddr flush_end);
-
-    // Upload/Download data in gl_buffer in/to this surface's texture
-    void UploadGLTexture(const MathUtil::Rectangle<u32>& rect, GLuint read_fb_handle,
-                         GLuint draw_fb_handle);
-    void DownloadGLTexture(const MathUtil::Rectangle<u32>& rect, GLuint read_fb_handle,
-                           GLuint draw_fb_handle);
-};
-
-class RasterizerCacheOpenGL : NonCopyable {
-public:
-    RasterizerCacheOpenGL();
-    ~RasterizerCacheOpenGL();
-
-    /// Blit one surface's texture to another
-    bool BlitSurfaces(const Surface& src_surface, const MathUtil::Rectangle<u32>& src_rect,
-                      const Surface& dst_surface, const MathUtil::Rectangle<u32>& dst_rect);
-
-    void ConvertD24S8toABGR(GLuint src_tex, const MathUtil::Rectangle<u32>& src_rect,
-                            GLuint dst_tex, const MathUtil::Rectangle<u32>& dst_rect);
-
-    /// Copy one surface's region to another
-    void CopySurface(const Surface& src_surface, const Surface& dst_surface,
-                     SurfaceInterval copy_interval);
-
-    /// Load a texture from 3DS memory to OpenGL and cache it (if not already cached)
-    Surface GetSurface(const SurfaceParams& params, ScaleMatch match_res_scale,
-                       bool load_if_create);
-
-    /// Attempt to find a subrect (resolution scaled) of a surface, otherwise loads a texture from
-    /// 3DS memory to OpenGL and caches it (if not already cached)
-    SurfaceRect_Tuple GetSurfaceSubRect(const SurfaceParams& params, ScaleMatch match_res_scale,
-                                        bool load_if_create);
-
-    /// Get a surface based on the texture configuration
-    Surface GetTextureSurface(const void* config);
-
-    /// Get the color and depth surfaces based on the framebuffer configuration
-    SurfaceSurfaceRect_Tuple GetFramebufferSurfaces(bool using_color_fb, bool using_depth_fb,
-                                                    const MathUtil::Rectangle<s32>& viewport_rect);
-
-    /// Get a surface that matches the fill config
-    Surface GetFillSurface(const void* config);
-
-    /// Get a surface that matches a "texture copy" display transfer config
-    SurfaceRect_Tuple GetTexCopySurface(const SurfaceParams& params);
-
-    /// Write any cached resources overlapping the region back to memory (if dirty)
-    void FlushRegion(VAddr addr, u64 size, Surface flush_surface = nullptr);
-
-    /// Mark region as being invalidated by region_owner (nullptr if 3DS memory)
-    void InvalidateRegion(VAddr addr, u64 size, const Surface& region_owner);
-
-    /// Flush all cached resources tracked by this cache manager
-    void FlushAll();
-
-private:
-    void DuplicateSurface(const Surface& src_surface, const Surface& dest_surface);
-
-    /// Update surface's texture for given region when necessary
-    void ValidateSurface(const Surface& surface, VAddr addr, u64 size);
-
-    /// Create a new surface
-    Surface CreateSurface(const SurfaceParams& params);
-
-    /// Register surface into the cache
-    void RegisterSurface(const Surface& surface);
-
-    /// Remove surface from the cache
-    void UnregisterSurface(const Surface& surface);
-
-    /// Increase/decrease the number of surface in pages touching the specified region
-    void UpdatePagesCachedCount(VAddr addr, u64 size, int delta);
-
-    SurfaceCache surface_cache;
-    PageMap cached_pages;
-    SurfaceMap dirty_regions;
-    SurfaceSet remove_surfaces;
-
-    OGLFramebuffer read_framebuffer;
-    OGLFramebuffer draw_framebuffer;
-
-    OGLVertexArray attributeless_vao;
-    OGLBuffer d24s8_abgr_buffer;
-    GLsizeiptr d24s8_abgr_buffer_size;
-    OGLShader d24s8_abgr_shader;
-    GLint d24s8_abgr_tbo_size_u_id;
-    GLint d24s8_abgr_viewport_u_id;
-};

src/video_core/renderer_opengl/gl_resource_manager.h

@@ -36,7 +36,7 @@ public:
         if (handle == 0)
             return;
         glDeleteTextures(1, &handle);
-        OpenGLState::GetCurState().ResetTexture(handle).Apply();
+        OpenGLState::ResetTexture(handle);
         handle = 0;
     }
 
@@ -69,7 +69,7 @@ public:
         if (handle == 0)
             return;
         glDeleteSamplers(1, &handle);
-        OpenGLState::GetCurState().ResetSampler(handle).Apply();
+        OpenGLState::ResetSampler(handle);
         handle = 0;
     }
 
@@ -91,13 +91,10 @@ public:
     }
 
     /// Creates a new internal OpenGL resource and stores the handle
-    void Create(const char* vert_shader, const char* geo_shader, const char* frag_shader,
-                const std::vector<const char*>& feedback_vars = {},
-                bool separable_program = false) {
+    void Create(const char* vert_shader, const char* frag_shader) {
         if (handle != 0)
             return;
-        handle = GLShader::LoadProgram(vert_shader, geo_shader, frag_shader, feedback_vars,
-                                       separable_program);
+        handle = GLShader::LoadProgram(vert_shader, frag_shader);
     }
 
     /// Deletes the internal OpenGL resource
@@ -105,40 +102,7 @@ public:
         if (handle == 0)
             return;
         glDeleteProgram(handle);
-        OpenGLState::GetCurState().ResetProgram(handle).Apply();
-        handle = 0;
-    }
-
-    GLuint handle = 0;
-};
-
-class OGLPipeline : private NonCopyable {
-public:
-    OGLPipeline() = default;
-    OGLPipeline(OGLPipeline&& o) {
-        handle = std::exchange<GLuint>(o.handle, 0);
-    }
-    ~OGLPipeline() {
-        Release();
-    }
-    OGLPipeline& operator=(OGLPipeline&& o) {
-        handle = std::exchange<GLuint>(o.handle, 0);
-        return *this;
-    }
-
-    /// Creates a new internal OpenGL resource and stores the handle
-    void Create() {
-        if (handle != 0)
-            return;
-        glGenProgramPipelines(1, &handle);
-    }
-
-    /// Deletes the internal OpenGL resource
-    void Release() {
-        if (handle == 0)
-            return;
-        glDeleteProgramPipelines(1, &handle);
-        OpenGLState::GetCurState().ResetPipeline(handle).Apply();
+        OpenGLState::ResetProgram(handle);
         handle = 0;
     }
 
@@ -171,46 +135,13 @@ public:
         if (handle == 0)
             return;
         glDeleteBuffers(1, &handle);
-        OpenGLState::GetCurState().ResetBuffer(handle).Apply();
+        OpenGLState::ResetBuffer(handle);
         handle = 0;
     }
 
     GLuint handle = 0;
 };
 
-class OGLSync : private NonCopyable {
-public:
-    OGLSync() = default;
-
-    OGLSync(OGLSync&& o) : handle(std::exchange(o.handle, nullptr)) {}
-
-    ~OGLSync() {
-        Release();
-    }
-    OGLSync& operator=(OGLSync&& o) {
-        Release();
-        handle = std::exchange(o.handle, nullptr);
-        return *this;
-    }
-
-    /// Creates a new internal OpenGL resource and stores the handle
-    void Create() {
-        if (handle != 0)
-            return;
-        handle = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
-    }
-
-    /// Deletes the internal OpenGL resource
-    void Release() {
-        if (handle == 0)
-            return;
-        glDeleteSync(handle);
-        handle = 0;
-    }
-
-    GLsync handle = 0;
-};
-
 class OGLVertexArray : private NonCopyable {
 public:
     OGLVertexArray() = default;
@@ -237,7 +168,7 @@ public:
         if (handle == 0)
             return;
         glDeleteVertexArrays(1, &handle);
-        OpenGLState::GetCurState().ResetVertexArray(handle).Apply();
+        OpenGLState::ResetVertexArray(handle);
         handle = 0;
     }
 
@@ -270,7 +201,7 @@ public:
         if (handle == 0)
             return;
         glDeleteFramebuffers(1, &handle);
-        OpenGLState::GetCurState().ResetFramebuffer(handle).Apply();
+        OpenGLState::ResetFramebuffer(handle);
         handle = 0;
     }
 

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -1,58 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string>
-#include <queue>
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "video_core/renderer_opengl/gl_shader_decompiler.h"
-
-namespace Maxwell3D {
-namespace Shader {
-namespace Decompiler {
-
-constexpr u32 PROGRAM_END = MAX_PROGRAM_CODE_LENGTH;
-
-class Impl {
-public:
-    Impl(const std::array<u32, MAX_PROGRAM_CODE_LENGTH>& program_code,
-         const std::array<u32, MAX_SWIZZLE_DATA_LENGTH>& swizzle_data, u32 main_offset,
-         const std::function<std::string(u32)>& inputreg_getter,
-         const std::function<std::string(u32)>& outputreg_getter, bool sanitize_mul,
-         const std::string& emit_cb, const std::string& setemit_cb)
-        : program_code(program_code), swizzle_data(swizzle_data), main_offset(main_offset),
-          inputreg_getter(inputreg_getter), outputreg_getter(outputreg_getter),
-          sanitize_mul(sanitize_mul), emit_cb(emit_cb), setemit_cb(setemit_cb) {}
-
-    std::string Decompile() {
-        UNIMPLEMENTED();
-        return {};
-    }
-
-private:
-    const std::array<u32, MAX_PROGRAM_CODE_LENGTH>& program_code;
-    const std::array<u32, MAX_SWIZZLE_DATA_LENGTH>& swizzle_data;
-    u32 main_offset;
-    const std::function<std::string(u32)>& inputreg_getter;
-    const std::function<std::string(u32)>& outputreg_getter;
-    bool sanitize_mul;
-    const std::string& emit_cb;
-    const std::string& setemit_cb;
-};
-
-std::string DecompileProgram(const std::array<u32, MAX_PROGRAM_CODE_LENGTH>& program_code,
-                             const std::array<u32, MAX_SWIZZLE_DATA_LENGTH>& swizzle_data,
-                             u32 main_offset,
-                             const std::function<std::string(u32)>& inputreg_getter,
-                             const std::function<std::string(u32)>& outputreg_getter,
-                             bool sanitize_mul, const std::string& emit_cb,
-                             const std::string& setemit_cb) {
-    Impl impl(program_code, swizzle_data, main_offset, inputreg_getter, outputreg_getter,
-              sanitize_mul, emit_cb, setemit_cb);
-    return impl.Decompile();
-}
-
-} // namespace Decompiler
-} // namespace Shader
-} // namespace Maxwell3D

src/video_core/renderer_opengl/gl_shader_decompiler.h

@@ -1,27 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <array>
-#include <functional>
-#include <string>
-#include "common/common_types.h"
-
-namespace Maxwell3D {
-namespace Shader {
-namespace Decompiler {
-
-constexpr size_t MAX_PROGRAM_CODE_LENGTH{0x100000};
-constexpr size_t MAX_SWIZZLE_DATA_LENGTH{0x100000};
-
-std::string DecompileProgram(const std::array<u32, MAX_PROGRAM_CODE_LENGTH>& program_code,
-                             const std::array<u32, MAX_SWIZZLE_DATA_LENGTH>& swizzle_data,
-                             u32 main_offset,
-                             const std::function<std::string(u32)>& inputreg_getter,
-                             const std::function<std::string(u32)>& outputreg_getter,
-                             bool sanitize_mul, const std::string& emit_cb = "",
-                             const std::string& setemit_cb = "");
-
-} // namespace Decompiler
-} // namespace Shader
-} // namespace Maxwell3D

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -1,20 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "video_core/renderer_opengl/gl_shader_gen.h"
-
-namespace GLShader {
-
-std::string GenerateVertexShader(const MaxwellVSConfig& config) {
-    UNIMPLEMENTED();
-    return {};
-}
-
-std::string GenerateFragmentShader(const MaxwellFSConfig& config) {
-    UNIMPLEMENTED();
-    return {};
-}
-
-} // namespace GLShader

src/video_core/renderer_opengl/gl_shader_gen.h

@@ -1,66 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstring>
-#include <string>
-#include <type_traits>
-#include "common/hash.h"
-
-namespace GLShader {
-
-enum Attributes {
-    ATTRIBUTE_POSITION,
-    ATTRIBUTE_COLOR,
-    ATTRIBUTE_TEXCOORD0,
-    ATTRIBUTE_TEXCOORD1,
-    ATTRIBUTE_TEXCOORD2,
-    ATTRIBUTE_TEXCOORD0_W,
-    ATTRIBUTE_NORMQUAT,
-    ATTRIBUTE_VIEW,
-};
-
-struct MaxwellShaderConfigCommon {
-    explicit MaxwellShaderConfigCommon(){};
-};
-
-struct MaxwellVSConfig : MaxwellShaderConfigCommon {
-    explicit MaxwellVSConfig() : MaxwellShaderConfigCommon() {}
-
-    bool operator==(const MaxwellVSConfig& o) const {
-        return std::memcmp(this, &o, sizeof(MaxwellVSConfig)) == 0;
-    };
-};
-
-struct MaxwellFSConfig : MaxwellShaderConfigCommon {
-    explicit MaxwellFSConfig() : MaxwellShaderConfigCommon() {}
-
-    bool operator==(const MaxwellFSConfig& o) const {
-        return std::memcmp(this, &o, sizeof(MaxwellFSConfig)) == 0;
-    };
-};
-
-std::string GenerateVertexShader(const MaxwellVSConfig& config);
-std::string GenerateFragmentShader(const MaxwellFSConfig& config);
-
-} // namespace GLShader
-
-namespace std {
-
-template <>
-struct hash<GLShader::MaxwellVSConfig> {
-    size_t operator()(const GLShader::MaxwellVSConfig& k) const {
-        return Common::ComputeHash64(&k, sizeof(GLShader::MaxwellVSConfig));
-    }
-};
-
-template <>
-struct hash<GLShader::MaxwellFSConfig> {
-    size_t operator()(const GLShader::MaxwellFSConfig& k) const {
-        return Common::ComputeHash64(&k, sizeof(GLShader::MaxwellFSConfig));
-    }
-};
-
-} // namespace std

src/video_core/renderer_opengl/gl_shader_util.cpp

@@ -10,85 +10,53 @@
 
 namespace GLShader {
 
-GLuint LoadProgram(const char* vertex_shader, const char* geometry_shader,
-                   const char* fragment_shader, const std::vector<const char*>& feedback_vars,
-                   bool separable_program) {
+GLuint LoadProgram(const char* vertex_shader, const char* fragment_shader) {
+
     // Create the shaders
-    GLuint vertex_shader_id = vertex_shader ? glCreateShader(GL_VERTEX_SHADER) : 0;
-    GLuint geometry_shader_id = geometry_shader ? glCreateShader(GL_GEOMETRY_SHADER) : 0;
-    GLuint fragment_shader_id = fragment_shader ? glCreateShader(GL_FRAGMENT_SHADER) : 0;
+    GLuint vertex_shader_id = glCreateShader(GL_VERTEX_SHADER);
+    GLuint fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER);
 
     GLint result = GL_FALSE;
     int info_log_length;
 
-    if (vertex_shader) {
-        // Compile Vertex Shader
-        LOG_DEBUG(Render_OpenGL, "Compiling vertex shader...");
+    // Compile Vertex Shader
+    LOG_DEBUG(Render_OpenGL, "Compiling vertex shader...");
 
-        glShaderSource(vertex_shader_id, 1, &vertex_shader, nullptr);
-        glCompileShader(vertex_shader_id);
+    glShaderSource(vertex_shader_id, 1, &vertex_shader, nullptr);
+    glCompileShader(vertex_shader_id);
 
-        // Check Vertex Shader
-        glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS, &result);
-        glGetShaderiv(vertex_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
+    // Check Vertex Shader
+    glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS, &result);
+    glGetShaderiv(vertex_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
 
-        if (info_log_length > 1) {
-            std::vector<char> vertex_shader_error(info_log_length);
-            glGetShaderInfoLog(vertex_shader_id, info_log_length, nullptr, &vertex_shader_error[0]);
-            if (result == GL_TRUE) {
-                LOG_DEBUG(Render_OpenGL, "%s", &vertex_shader_error[0]);
-            } else {
-                LOG_ERROR(Render_OpenGL, "Error compiling vertex shader:\n%s",
-                          &vertex_shader_error[0]);
-            }
+    if (info_log_length > 1) {
+        std::vector<char> vertex_shader_error(info_log_length);
+        glGetShaderInfoLog(vertex_shader_id, info_log_length, nullptr, &vertex_shader_error[0]);
+        if (result == GL_TRUE) {
+            LOG_DEBUG(Render_OpenGL, "%s", &vertex_shader_error[0]);
+        } else {
+            LOG_ERROR(Render_OpenGL, "Error compiling vertex shader:\n%s", &vertex_shader_error[0]);
         }
     }
 
-    if (geometry_shader) {
-        // Compile Geometry Shader
-        LOG_DEBUG(Render_OpenGL, "Compiling geometry shader...");
+    // Compile Fragment Shader
+    LOG_DEBUG(Render_OpenGL, "Compiling fragment shader...");
 
-        glShaderSource(geometry_shader_id, 1, &geometry_shader, nullptr);
-        glCompileShader(geometry_shader_id);
+    glShaderSource(fragment_shader_id, 1, &fragment_shader, nullptr);
+    glCompileShader(fragment_shader_id);
 
-        // Check Geometry Shader
-        glGetShaderiv(geometry_shader_id, GL_COMPILE_STATUS, &result);
-        glGetShaderiv(geometry_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
+    // Check Fragment Shader
+    glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS, &result);
+    glGetShaderiv(fragment_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
 
-        if (info_log_length > 1) {
-            std::vector<char> geometry_shader_error(info_log_length);
-            glGetShaderInfoLog(geometry_shader_id, info_log_length, nullptr,
-                               &geometry_shader_error[0]);
-            if (result == GL_TRUE) {
-                LOG_DEBUG(Render_OpenGL, "%s", &geometry_shader_error[0]);
-            } else {
-                LOG_ERROR(Render_OpenGL, "Error compiling geometry shader:\n%s",
-                          &geometry_shader_error[0]);
-            }
-        }
-    }
-
-    if (fragment_shader) {
-        // Compile Fragment Shader
-        LOG_DEBUG(Render_OpenGL, "Compiling fragment shader...");
-
-        glShaderSource(fragment_shader_id, 1, &fragment_shader, nullptr);
-        glCompileShader(fragment_shader_id);
-
-        // Check Fragment Shader
-        glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS, &result);
-        glGetShaderiv(fragment_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
-
-        if (info_log_length > 1) {
-            std::vector<char> fragment_shader_error(info_log_length);
-            glGetShaderInfoLog(fragment_shader_id, info_log_length, nullptr,
-                               &fragment_shader_error[0]);
-            if (result == GL_TRUE) {
-                LOG_DEBUG(Render_OpenGL, "%s", &fragment_shader_error[0]);
-            } else {
-                LOG_ERROR(Render_OpenGL, "Error compiling fragment shader:\n%s",
-                          &fragment_shader_error[0]);
-            }
+    if (info_log_length > 1) {
+        std::vector<char> fragment_shader_error(info_log_length);
+        glGetShaderInfoLog(fragment_shader_id, info_log_length, nullptr, &fragment_shader_error[0]);
+        if (result == GL_TRUE) {
+            LOG_DEBUG(Render_OpenGL, "%s", &fragment_shader_error[0]);
+        } else {
+            LOG_ERROR(Render_OpenGL, "Error compiling fragment shader:\n%s",
+                      &fragment_shader_error[0]);
         }
     }
 
@@ -96,25 +64,8 @@ GLuint LoadProgram(const char* vertex_shader, const char* geometry_shader,
     LOG_DEBUG(Render_OpenGL, "Linking program...");
 
     GLuint program_id = glCreateProgram();
-    if (vertex_shader) {
-        glAttachShader(program_id, vertex_shader_id);
-    }
-    if (geometry_shader) {
-        glAttachShader(program_id, geometry_shader_id);
-    }
-    if (fragment_shader) {
-        glAttachShader(program_id, fragment_shader_id);
-    }
-
-    if (!feedback_vars.empty()) {
-        auto varyings = feedback_vars;
-        glTransformFeedbackVaryings(program_id, static_cast<GLsizei>(feedback_vars.size()),
-                                    &varyings[0], GL_INTERLEAVED_ATTRIBS);
-    }
-
-    if (separable_program) {
-        glProgramParameteri(program_id, GL_PROGRAM_SEPARABLE, GL_TRUE);
-    }
+    glAttachShader(program_id, vertex_shader_id);
+    glAttachShader(program_id, fragment_shader_id);
 
     glLinkProgram(program_id);
 
@@ -134,30 +85,13 @@ GLuint LoadProgram(const char* vertex_shader, const char* geometry_shader,
 
     // If the program linking failed at least one of the shaders was probably bad
     if (result == GL_FALSE) {
-        if (vertex_shader) {
-            LOG_ERROR(Render_OpenGL, "Vertex shader:\n%s", vertex_shader);
-        }
-        if (geometry_shader) {
-            LOG_ERROR(Render_OpenGL, "Geometry shader:\n%s", geometry_shader);
-        }
-        if (fragment_shader) {
-            LOG_ERROR(Render_OpenGL, "Fragment shader:\n%s", fragment_shader);
-        }
+        LOG_ERROR(Render_OpenGL, "Vertex shader:\n%s", vertex_shader);
+        LOG_ERROR(Render_OpenGL, "Fragment shader:\n%s", fragment_shader);
     }
     ASSERT_MSG(result == GL_TRUE, "Shader not linked");
 
-    if (vertex_shader) {
-        glDetachShader(program_id, vertex_shader_id);
-        glDeleteShader(vertex_shader_id);
-    }
-    if (geometry_shader) {
-        glDetachShader(program_id, geometry_shader_id);
-        glDeleteShader(geometry_shader_id);
-    }
-    if (fragment_shader) {
-        glDetachShader(program_id, fragment_shader_id);
-        glDeleteShader(fragment_shader_id);
-    }
+    glDeleteShader(vertex_shader_id);
+    glDeleteShader(fragment_shader_id);
 
     return program_id;
 }

src/video_core/renderer_opengl/gl_shader_util.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <vector>
 #include <glad/glad.h>
 
 namespace GLShader {
@@ -12,12 +11,9 @@ namespace GLShader {
 /**
  * Utility function to create and compile an OpenGL GLSL shader program (vertex + fragment shader)
  * @param vertex_shader String of the GLSL vertex shader program
- * @param geometry_shader String of the GLSL geometry shader program
  * @param fragment_shader String of the GLSL fragment shader program
  * @returns Handle of the newly created OpenGL shader object
  */
-GLuint LoadProgram(const char* vertex_shader, const char* geometry_shader,
-                   const char* fragment_shader, const std::vector<const char*>& feedback_vars = {},
-                   bool separable_program = false);
+GLuint LoadProgram(const char* vertex_shader, const char* fragment_shader);
 
 } // namespace GLShader

src/video_core/renderer_opengl/gl_state.cpp

@@ -33,7 +33,7 @@ OpenGLState::OpenGLState() {
     stencil.action_depth_pass = GL_KEEP;
     stencil.action_stencil_fail = GL_KEEP;
 
-    blend.enabled = true;
+    blend.enabled = false;
     blend.rgb_equation = GL_FUNC_ADD;
     blend.a_equation = GL_FUNC_ADD;
     blend.src_rgb_func = GL_ONE;
@@ -68,18 +68,6 @@ OpenGLState::OpenGLState() {
     draw.vertex_buffer = 0;
     draw.uniform_buffer = 0;
     draw.shader_program = 0;
-    draw.program_pipeline = 0;
-
-    scissor.enabled = false;
-    scissor.x = 0;
-    scissor.y = 0;
-    scissor.width = 0;
-    scissor.height = 0;
-
-    viewport.x = 0;
-    viewport.y = 0;
-    viewport.width = 0;
-    viewport.height = 0;
 
     clip_distance = {};
 }
@@ -160,6 +148,9 @@ void OpenGLState::Apply() const {
     if (blend.enabled != cur_state.blend.enabled) {
         if (blend.enabled) {
             glEnable(GL_BLEND);
+
+            cur_state.logic_op = GL_COPY;
+            glLogicOp(cur_state.logic_op);
             glDisable(GL_COLOR_LOGIC_OP);
         } else {
             glDisable(GL_BLEND);
@@ -205,7 +196,7 @@ void OpenGLState::Apply() const {
     // Lighting LUTs
     if (lighting_lut.texture_buffer != cur_state.lighting_lut.texture_buffer) {
         glActiveTexture(TextureUnits::LightingLUT.Enum());
-        glBindTexture(GL_TEXTURE_BUFFER, lighting_lut.texture_buffer);
+        glBindTexture(GL_TEXTURE_BUFFER, cur_state.lighting_lut.texture_buffer);
     }
 
     // Fog LUT
@@ -272,31 +263,6 @@ void OpenGLState::Apply() const {
         glUseProgram(draw.shader_program);
     }
 
-    // Program pipeline
-    if (draw.program_pipeline != cur_state.draw.program_pipeline) {
-        glBindProgramPipeline(draw.program_pipeline);
-    }
-
-    // Scissor test
-    if (scissor.enabled != cur_state.scissor.enabled) {
-        if (scissor.enabled) {
-            glEnable(GL_SCISSOR_TEST);
-        } else {
-            glDisable(GL_SCISSOR_TEST);
-        }
-    }
-
-    if (scissor.x != cur_state.scissor.x || scissor.y != cur_state.scissor.y ||
-        scissor.width != cur_state.scissor.width || scissor.height != cur_state.scissor.height) {
-        glScissor(scissor.x, scissor.y, scissor.width, scissor.height);
-    }
-
-    if (viewport.x != cur_state.viewport.x || viewport.y != cur_state.viewport.y ||
-        viewport.width != cur_state.viewport.width ||
-        viewport.height != cur_state.viewport.height) {
-        glViewport(viewport.x, viewport.y, viewport.width, viewport.height);
-    }
-
     // Clip distance
     for (size_t i = 0; i < clip_distance.size(); ++i) {
         if (clip_distance[i] != cur_state.clip_distance[i]) {
@@ -311,75 +277,62 @@ void OpenGLState::Apply() const {
     cur_state = *this;
 }
 
-OpenGLState& OpenGLState::ResetTexture(GLuint handle) {
-    for (auto& unit : texture_units) {
+void OpenGLState::ResetTexture(GLuint handle) {
+    for (auto& unit : cur_state.texture_units) {
         if (unit.texture_2d == handle) {
             unit.texture_2d = 0;
         }
     }
-    if (lighting_lut.texture_buffer == handle)
-        lighting_lut.texture_buffer = 0;
-    if (fog_lut.texture_buffer == handle)
-        fog_lut.texture_buffer = 0;
-    if (proctex_noise_lut.texture_buffer == handle)
-        proctex_noise_lut.texture_buffer = 0;
-    if (proctex_color_map.texture_buffer == handle)
-        proctex_color_map.texture_buffer = 0;
-    if (proctex_alpha_map.texture_buffer == handle)
-        proctex_alpha_map.texture_buffer = 0;
-    if (proctex_lut.texture_buffer == handle)
-        proctex_lut.texture_buffer = 0;
-    if (proctex_diff_lut.texture_buffer == handle)
-        proctex_diff_lut.texture_buffer = 0;
-    return *this;
+    if (cur_state.lighting_lut.texture_buffer == handle)
+        cur_state.lighting_lut.texture_buffer = 0;
+    if (cur_state.fog_lut.texture_buffer == handle)
+        cur_state.fog_lut.texture_buffer = 0;
+    if (cur_state.proctex_noise_lut.texture_buffer == handle)
+        cur_state.proctex_noise_lut.texture_buffer = 0;
+    if (cur_state.proctex_color_map.texture_buffer == handle)
+        cur_state.proctex_color_map.texture_buffer = 0;
+    if (cur_state.proctex_alpha_map.texture_buffer == handle)
+        cur_state.proctex_alpha_map.texture_buffer = 0;
+    if (cur_state.proctex_lut.texture_buffer == handle)
+        cur_state.proctex_lut.texture_buffer = 0;
+    if (cur_state.proctex_diff_lut.texture_buffer == handle)
+        cur_state.proctex_diff_lut.texture_buffer = 0;
 }
 
-OpenGLState& OpenGLState::ResetSampler(GLuint handle) {
-    for (auto& unit : texture_units) {
+void OpenGLState::ResetSampler(GLuint handle) {
+    for (auto& unit : cur_state.texture_units) {
         if (unit.sampler == handle) {
             unit.sampler = 0;
         }
     }
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetProgram(GLuint handle) {
-    if (draw.shader_program == handle) {
-        draw.shader_program = 0;
+void OpenGLState::ResetProgram(GLuint handle) {
+    if (cur_state.draw.shader_program == handle) {
+        cur_state.draw.shader_program = 0;
     }
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetPipeline(GLuint handle) {
-    if (draw.program_pipeline == handle) {
-        draw.program_pipeline = 0;
+void OpenGLState::ResetBuffer(GLuint handle) {
+    if (cur_state.draw.vertex_buffer == handle) {
+        cur_state.draw.vertex_buffer = 0;
+    }
+    if (cur_state.draw.uniform_buffer == handle) {
+        cur_state.draw.uniform_buffer = 0;
     }
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetBuffer(GLuint handle) {
-    if (draw.vertex_buffer == handle) {
-        draw.vertex_buffer = 0;
+void OpenGLState::ResetVertexArray(GLuint handle) {
+    if (cur_state.draw.vertex_array == handle) {
+        cur_state.draw.vertex_array = 0;
     }
-    if (draw.uniform_buffer == handle) {
-        draw.uniform_buffer = 0;
-    }
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetVertexArray(GLuint handle) {
-    if (draw.vertex_array == handle) {
-        draw.vertex_array = 0;
+void OpenGLState::ResetFramebuffer(GLuint handle) {
+    if (cur_state.draw.read_framebuffer == handle) {
+        cur_state.draw.read_framebuffer = 0;
+    }
+    if (cur_state.draw.draw_framebuffer == handle) {
+        cur_state.draw.draw_framebuffer = 0;
     }
-    return *this;
-}
-
-OpenGLState& OpenGLState::ResetFramebuffer(GLuint handle) {
-    if (draw.read_framebuffer == handle) {
-        draw.read_framebuffer = 0;
-    }
-    if (draw.draw_framebuffer == handle) {
-        draw.draw_framebuffer = 0;
-    }
-    return *this;
 }

src/video_core/renderer_opengl/gl_state.h

@@ -122,44 +122,27 @@ public:
         GLuint vertex_buffer;    // GL_ARRAY_BUFFER_BINDING
         GLuint uniform_buffer;   // GL_UNIFORM_BUFFER_BINDING
         GLuint shader_program;   // GL_CURRENT_PROGRAM
-        GLuint program_pipeline; // GL_PROGRAM_PIPELINE_BINDING
     } draw;
 
-    struct {
-        bool enabled; // GL_SCISSOR_TEST
-        GLint x;
-        GLint y;
-        GLsizei width;
-        GLsizei height;
-    } scissor;
-
-    struct {
-        GLint x;
-        GLint y;
-        GLsizei width;
-        GLsizei height;
-    } viewport;
-
     std::array<bool, 2> clip_distance; // GL_CLIP_DISTANCE
 
     OpenGLState();
 
     /// Get the currently active OpenGL state
-    static OpenGLState GetCurState() {
+    static const OpenGLState& GetCurState() {
         return cur_state;
     }
 
     /// Apply this state as the current OpenGL state
     void Apply() const;
 
-    /// Resets any references to the given resource
-    OpenGLState& ResetTexture(GLuint handle);
-    OpenGLState& ResetSampler(GLuint handle);
-    OpenGLState& ResetProgram(GLuint handle);
-    OpenGLState& ResetPipeline(GLuint handle);
-    OpenGLState& ResetBuffer(GLuint handle);
-    OpenGLState& ResetVertexArray(GLuint handle);
-    OpenGLState& ResetFramebuffer(GLuint handle);
+    /// Resets and unbinds any references to the given resource in the current OpenGL state
+    static void ResetTexture(GLuint handle);
+    static void ResetSampler(GLuint handle);
+    static void ResetProgram(GLuint handle);
+    static void ResetBuffer(GLuint handle);
+    static void ResetVertexArray(GLuint handle);
+    static void ResetFramebuffer(GLuint handle);
 
 private:
     static OpenGLState cur_state;

src/video_core/renderer_opengl/gl_stream_buffer.cpp

@@ -1,182 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <deque>
-#include <vector>
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "video_core/renderer_opengl/gl_state.h"
-#include "video_core/renderer_opengl/gl_stream_buffer.h"
-
-class OrphanBuffer : public OGLStreamBuffer {
-public:
-    explicit OrphanBuffer(GLenum target) : OGLStreamBuffer(target) {}
-    ~OrphanBuffer() override;
-
-private:
-    void Create(size_t size, size_t sync_subdivide) override;
-    void Release() override;
-
-    std::pair<u8*, GLintptr> Map(size_t size, size_t alignment) override;
-    void Unmap() override;
-
-    std::vector<u8> data;
-};
-
-class StorageBuffer : public OGLStreamBuffer {
-public:
-    explicit StorageBuffer(GLenum target) : OGLStreamBuffer(target) {}
-    ~StorageBuffer() override;
-
-private:
-    void Create(size_t size, size_t sync_subdivide) override;
-    void Release() override;
-
-    std::pair<u8*, GLintptr> Map(size_t size, size_t alignment) override;
-    void Unmap() override;
-
-    struct Fence {
-        OGLSync sync;
-        size_t offset;
-    };
-    std::deque<Fence> head;
-    std::deque<Fence> tail;
-
-    u8* mapped_ptr;
-};
-
-OGLStreamBuffer::OGLStreamBuffer(GLenum target) {
-    gl_target = target;
-}
-
-GLuint OGLStreamBuffer::GetHandle() const {
-    return gl_buffer.handle;
-}
-
-std::unique_ptr<OGLStreamBuffer> OGLStreamBuffer::MakeBuffer(bool storage_buffer, GLenum target) {
-    if (storage_buffer) {
-        return std::make_unique<StorageBuffer>(target);
-    }
-    return std::make_unique<OrphanBuffer>(target);
-}
-
-OrphanBuffer::~OrphanBuffer() {
-    Release();
-}
-
-void OrphanBuffer::Create(size_t size, size_t /*sync_subdivide*/) {
-    buffer_pos = 0;
-    buffer_size = size;
-    data.resize(buffer_size);
-
-    if (gl_buffer.handle == 0) {
-        gl_buffer.Create();
-        glBindBuffer(gl_target, gl_buffer.handle);
-    }
-
-    glBufferData(gl_target, static_cast<GLsizeiptr>(buffer_size), nullptr, GL_STREAM_DRAW);
-}
-
-void OrphanBuffer::Release() {
-    gl_buffer.Release();
-}
-
-std::pair<u8*, GLintptr> OrphanBuffer::Map(size_t size, size_t alignment) {
-    buffer_pos = Common::AlignUp(buffer_pos, alignment);
-
-    if (buffer_pos + size > buffer_size) {
-        Create(std::max(buffer_size, size), 0);
-    }
-
-    mapped_size = size;
-    return std::make_pair(&data[buffer_pos], static_cast<GLintptr>(buffer_pos));
-}
-
-void OrphanBuffer::Unmap() {
-    glBufferSubData(gl_target, static_cast<GLintptr>(buffer_pos),
-                    static_cast<GLsizeiptr>(mapped_size), &data[buffer_pos]);
-    buffer_pos += mapped_size;
-}
-
-StorageBuffer::~StorageBuffer() {
-    Release();
-}
-
-void StorageBuffer::Create(size_t size, size_t sync_subdivide) {
-    if (gl_buffer.handle != 0)
-        return;
-
-    buffer_pos = 0;
-    buffer_size = size;
-    buffer_sync_subdivide = std::max<size_t>(sync_subdivide, 1);
-
-    gl_buffer.Create();
-    glBindBuffer(gl_target, gl_buffer.handle);
-
-    glBufferStorage(gl_target, static_cast<GLsizeiptr>(buffer_size), nullptr,
-                    GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
-    mapped_ptr = reinterpret_cast<u8*>(
-        glMapBufferRange(gl_target, 0, static_cast<GLsizeiptr>(buffer_size),
-                         GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_FLUSH_EXPLICIT_BIT));
-}
-
-void StorageBuffer::Release() {
-    if (gl_buffer.handle == 0)
-        return;
-
-    glUnmapBuffer(gl_target);
-
-    gl_buffer.Release();
-    head.clear();
-    tail.clear();
-}
-
-std::pair<u8*, GLintptr> StorageBuffer::Map(size_t size, size_t alignment) {
-    ASSERT(size <= buffer_size);
-
-    OGLSync sync;
-
-    buffer_pos = Common::AlignUp(buffer_pos, alignment);
-    size_t effective_offset = Common::AlignDown(buffer_pos, buffer_sync_subdivide);
-
-    if (!head.empty() &&
-        (effective_offset > head.back().offset || buffer_pos + size > buffer_size)) {
-        ASSERT(head.back().sync.handle == 0);
-        head.back().sync.Create();
-    }
-
-    if (buffer_pos + size > buffer_size) {
-        if (!tail.empty()) {
-            std::swap(sync, tail.back().sync);
-            tail.clear();
-        }
-        std::swap(tail, head);
-        buffer_pos = 0;
-        effective_offset = 0;
-    }
-
-    while (!tail.empty() && buffer_pos + size > tail.front().offset) {
-        std::swap(sync, tail.front().sync);
-        tail.pop_front();
-    }
-
-    if (sync.handle != 0) {
-        glClientWaitSync(sync.handle, GL_SYNC_FLUSH_COMMANDS_BIT, GL_TIMEOUT_IGNORED);
-        sync.Release();
-    }
-
-    if (head.empty() || effective_offset > head.back().offset) {
-        head.emplace_back();
-        head.back().offset = effective_offset;
-    }
-
-    mapped_size = size;
-    return std::make_pair(&mapped_ptr[buffer_pos], static_cast<GLintptr>(buffer_pos));
-}
-
-void StorageBuffer::Unmap() {
-    glFlushMappedBufferRange(gl_target, static_cast<GLintptr>(buffer_pos),
-                             static_cast<GLsizeiptr>(mapped_size));
-    buffer_pos += mapped_size;
-}

src/video_core/renderer_opengl/gl_stream_buffer.h

@@ -1,34 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <memory>
-#include <glad/glad.h>
-#include "common/common_types.h"
-#include "video_core/renderer_opengl/gl_resource_manager.h"
-
-class OGLStreamBuffer : private NonCopyable {
-public:
-    explicit OGLStreamBuffer(GLenum target);
-    virtual ~OGLStreamBuffer() = default;
-
-public:
-    static std::unique_ptr<OGLStreamBuffer> MakeBuffer(bool storage_buffer, GLenum target);
-
-    virtual void Create(size_t size, size_t sync_subdivide) = 0;
-    virtual void Release() {}
-
-    GLuint GetHandle() const;
-
-    virtual std::pair<u8*, GLintptr> Map(size_t size, size_t alignment) = 0;
-    virtual void Unmap() = 0;
-
-protected:
-    OGLBuffer gl_buffer;
-    GLenum gl_target;
-
-    size_t buffer_pos = 0;
-    size_t buffer_size = 0;
-    size_t buffer_sync_subdivide = 0;
-    size_t mapped_size = 0;
-};

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -20,7 +20,6 @@
 #include "core/settings.h"
 #include "core/tracer/recorder.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
-#include "video_core/utils.h"
 #include "video_core/video_core.h"
 
 static const char vertex_shader[] = R"(
@@ -99,22 +98,22 @@ RendererOpenGL::RendererOpenGL() = default;
 RendererOpenGL::~RendererOpenGL() = default;
 
 /// Swap buffers (render frame)
-void RendererOpenGL::SwapBuffers(boost::optional<const Tegra::FramebufferConfig&> framebuffer) {
+void RendererOpenGL::SwapBuffers(boost::optional<const FramebufferInfo&> framebuffer_info) {
     // Maintain the rasterizer's state as a priority
     OpenGLState prev_state = OpenGLState::GetCurState();
     state.Apply();
 
-    if (framebuffer != boost::none) {
-        // If framebuffer is provided, reload it from memory to a texture
-        if (screen_info.texture.width != (GLsizei)framebuffer->width ||
-            screen_info.texture.height != (GLsizei)framebuffer->height ||
-            screen_info.texture.pixel_format != framebuffer->pixel_format) {
+    if (framebuffer_info != boost::none) {
+        // If framebuffer_info is provided, reload it from memory to a texture
+        if (screen_info.texture.width != (GLsizei)framebuffer_info->width ||
+            screen_info.texture.height != (GLsizei)framebuffer_info->height ||
+            screen_info.texture.pixel_format != framebuffer_info->pixel_format) {
             // Reallocate texture if the framebuffer size has changed.
             // This is expected to not happen very often and hence should not be a
             // performance problem.
-            ConfigureFramebufferTexture(screen_info.texture, *framebuffer);
+            ConfigureFramebufferTexture(screen_info.texture, *framebuffer_info);
         }
-        LoadFBToScreenInfo(*framebuffer, screen_info);
+        LoadFBToScreenInfo(*framebuffer_info, screen_info);
     }
 
     DrawScreens();
@@ -132,59 +131,164 @@ void RendererOpenGL::SwapBuffers(boost::optional<const Tegra::FramebufferConfig&
     RefreshRasterizerSetting();
 }
 
+static inline u32 MortonInterleave128(u32 x, u32 y) {
+    // 128x128 Z-Order coordinate from 2D coordinates
+    static constexpr u32 xlut[] = {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042,
+        0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809,
+        0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000,
+        0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043,
+        0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a,
+        0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001,
+        0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048,
+        0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b,
+        0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002,
+        0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049,
+        0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840,
+        0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003,
+        0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a,
+        0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841,
+        0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008,
+        0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b,
+        0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842,
+        0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009,
+        0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800,
+        0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843,
+        0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a,
+        0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801,
+        0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848,
+        0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802,
+        0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849,
+        0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040,
+        0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803,
+        0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a,
+        0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041,
+        0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808,
+        0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b,
+        0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042,
+        0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809,
+        0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b,
+    };
+    static constexpr u32 ylut[] = {
+        0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090,
+        0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124,
+        0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200,
+        0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294,
+        0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330,
+        0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404,
+        0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0,
+        0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534,
+        0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610,
+        0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4,
+        0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780,
+        0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014,
+        0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0,
+        0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184,
+        0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220,
+        0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4,
+        0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390,
+        0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424,
+        0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500,
+        0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594,
+        0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630,
+        0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704,
+        0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0,
+        0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034,
+        0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110,
+        0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4,
+        0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280,
+        0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314,
+        0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0,
+        0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484,
+        0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520,
+        0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4,
+        0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690,
+        0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724,
+        0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4,
+    };
+    return xlut[x % 128] + ylut[y % 128];
+}
+
+static inline u32 GetMortonOffset128(u32 x, u32 y, u32 bytes_per_pixel) {
+    // Calculates the offset of the position of the pixel in Morton order
+    // Framebuffer images are split into 128x128 tiles.
+
+    const unsigned int block_height = 128;
+    const unsigned int coarse_x = x & ~127;
+
+    u32 i = MortonInterleave128(x, y);
+
+    const unsigned int offset = coarse_x * block_height;
+
+    return (i + offset) * bytes_per_pixel;
+}
+
+static void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixel, u32 gl_bytes_per_pixel,
+                                u8* morton_data, u8* gl_data, bool morton_to_gl) {
+    u8* data_ptrs[2];
+    for (unsigned y = 0; y < height; ++y) {
+        for (unsigned x = 0; x < width; ++x) {
+            const u32 coarse_y = y & ~127;
+            u32 morton_offset =
+                GetMortonOffset128(x, y, bytes_per_pixel) + coarse_y * width * bytes_per_pixel;
+            u32 gl_pixel_index = (x + (height - 1 - y) * width) * gl_bytes_per_pixel;
+
+            data_ptrs[morton_to_gl] = morton_data + morton_offset;
+            data_ptrs[!morton_to_gl] = &gl_data[gl_pixel_index];
+
+            memcpy(data_ptrs[0], data_ptrs[1], bytes_per_pixel);
+        }
+    }
+}
+
 /**
  * Loads framebuffer from emulated memory into the active OpenGL texture.
  */
-void RendererOpenGL::LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer,
+void RendererOpenGL::LoadFBToScreenInfo(const FramebufferInfo& framebuffer_info,
                                         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};
+    const u32 bpp{FramebufferInfo::BytesPerPixel(framebuffer_info.pixel_format)};
+    const u32 size_in_bytes{framebuffer_info.stride * framebuffer_info.height * bpp};
 
-    // TODO(bunnei): The framebuffer region should only be invalidated if it is written to, not
-    // every frame. When we find the right place for this, the below line can be removed.
-    Memory::RasterizerFlushVirtualRegion(framebuffer_addr, size_in_bytes,
-                                         Memory::FlushMode::Invalidate);
+    MortonCopyPixels128(framebuffer_info.width, framebuffer_info.height, bpp, 4,
+                        Memory::GetPointer(framebuffer_info.address), gl_framebuffer_data.data(),
+                        true);
 
-    // Framebuffer orientation handling
-    framebuffer_transform_flags = framebuffer.transform_flags;
+    LOG_TRACE(Render_OpenGL, "0x%08x bytes from 0x%llx(%dx%d), fmt %x", size_in_bytes,
+              framebuffer_info.address, framebuffer_info.width, framebuffer_info.height,
+              (int)framebuffer_info.pixel_format);
 
     // Ensure no bad interactions with GL_UNPACK_ALIGNMENT, which by default
     // only allows rows to have a memory alignement of 4.
-    ASSERT(framebuffer.stride % 4 == 0);
+    ASSERT(framebuffer_info.stride % 4 == 0);
 
-    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;
-        screen_info.display_texcoords = MathUtil::Rectangle<float>(0.f, 0.f, 1.f, 1.f);
+    framebuffer_flip_vertical = framebuffer_info.flip_vertical;
 
-        Rasterizer()->FlushRegion(framebuffer_addr, size_in_bytes);
+    // Reset the screen info's display texture to its own permanent texture
+    screen_info.display_texture = screen_info.texture.resource.handle;
+    screen_info.display_texcoords = MathUtil::Rectangle<float>(0.f, 0.f, 1.f, 1.f);
 
-        VideoCore::MortonCopyPixels128(framebuffer.width, framebuffer.height, bytes_per_pixel, 4,
-                                       Memory::GetPointer(framebuffer_addr),
-                                       gl_framebuffer_data.data(), true);
+    // Memory::RasterizerFlushRegion(framebuffer_info.address, size_in_bytes);
 
-        state.texture_units[0].texture_2d = screen_info.texture.resource.handle;
-        state.Apply();
+    state.texture_units[0].texture_2d = screen_info.texture.resource.handle;
+    state.Apply();
 
-        glActiveTexture(GL_TEXTURE0);
-        glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(framebuffer.stride));
+    glActiveTexture(GL_TEXTURE0);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint)framebuffer_info.stride);
 
-        // Update existing texture
-        // TODO: Test what happens on hardware when you change the framebuffer dimensions so that
-        //       they differ from the LCD resolution.
-        // TODO: Applications could theoretically crash yuzu here by specifying too large
-        //       framebuffer sizes. We should make sure that this cannot happen.
-        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, framebuffer.width, framebuffer.height,
-                        screen_info.texture.gl_format, screen_info.texture.gl_type,
-                        gl_framebuffer_data.data());
+    // Update existing texture
+    // TODO: Test what happens on hardware when you change the framebuffer dimensions so that
+    //       they differ from the LCD resolution.
+    // TODO: Applications could theoretically crash Citra here by specifying too large
+    //       framebuffer sizes. We should make sure that this cannot happen.
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, framebuffer_info.width, framebuffer_info.height,
+                    screen_info.texture.gl_format, screen_info.texture.gl_type,
+                    gl_framebuffer_data.data());
 
-        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 
-        state.texture_units[0].texture_2d = 0;
-        state.Apply();
-    }
+    state.texture_units[0].texture_2d = 0;
+    state.Apply();
 }
 
 /**
@@ -214,7 +318,7 @@ void RendererOpenGL::InitOpenGLObjects() {
                  0.0f);
 
     // Link shaders and get variable locations
-    shader.Create(vertex_shader, nullptr, fragment_shader);
+    shader.Create(vertex_shader, fragment_shader);
     state.draw.shader_program = shader.handle;
     state.Apply();
     uniform_modelview_matrix = glGetUniformLocation(shader.handle, "modelview_matrix");
@@ -268,14 +372,14 @@ void RendererOpenGL::InitOpenGLObjects() {
 }
 
 void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
-                                                 const Tegra::FramebufferConfig& framebuffer) {
+                                                 const FramebufferInfo& framebuffer_info) {
 
-    texture.width = framebuffer.width;
-    texture.height = framebuffer.height;
+    texture.width = framebuffer_info.width;
+    texture.height = framebuffer_info.height;
 
     GLint internal_format;
-    switch (framebuffer.pixel_format) {
-    case Tegra::FramebufferConfig::PixelFormat::ABGR8:
+    switch (framebuffer_info.pixel_format) {
+    case FramebufferInfo::PixelFormat::ABGR8:
         // Use RGBA8 and swap in the fragment shader
         internal_format = GL_RGBA;
         texture.gl_format = GL_RGBA;
@@ -300,19 +404,8 @@ void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
 void RendererOpenGL::DrawSingleScreen(const ScreenInfo& screen_info, float x, float y, float w,
                                       float h) {
     const auto& texcoords = screen_info.display_texcoords;
-    auto left = texcoords.left;
-    auto right = texcoords.right;
-    if (framebuffer_transform_flags != Tegra::FramebufferConfig::TransformFlags::Unset)
-        if (framebuffer_transform_flags == Tegra::FramebufferConfig::TransformFlags::FlipV) {
-            // Flip the framebuffer vertically
-            left = texcoords.right;
-            right = texcoords.left;
-        } else {
-            // Other transformations are unsupported
-            LOG_CRITICAL(HW_GPU, "unsupported framebuffer_transform_flags=%d",
-                         framebuffer_transform_flags);
-            UNIMPLEMENTED();
-        }
+    const auto& left = framebuffer_flip_vertical ? texcoords.right : texcoords.left;
+    const auto& right = framebuffer_flip_vertical ? texcoords.left : texcoords.right;
 
     std::array<ScreenRectVertex, 4> vertices = {{
         ScreenRectVertex(x, y, texcoords.top, right),

src/video_core/renderer_opengl/renderer_opengl.h

@@ -21,7 +21,7 @@ struct TextureInfo {
     GLsizei height;
     GLenum gl_format;
     GLenum gl_type;
-    Tegra::FramebufferConfig::PixelFormat pixel_format;
+    RendererBase::FramebufferInfo::PixelFormat pixel_format;
 };
 
 /// Structure used for storing information about the display target for each 3DS screen
@@ -37,7 +37,7 @@ public:
     ~RendererOpenGL() override;
 
     /// Swap buffers (render frame)
-    void SwapBuffers(boost::optional<const Tegra::FramebufferConfig&> framebuffer) override;
+    void SwapBuffers(boost::optional<const FramebufferInfo&> framebuffer_info) override;
 
     /**
      * Set the emulator window to use for renderer
@@ -53,14 +53,13 @@ public:
 
 private:
     void InitOpenGLObjects();
-    void ConfigureFramebufferTexture(TextureInfo& texture,
-                                     const Tegra::FramebufferConfig& framebuffer);
+    void ConfigureFramebufferTexture(TextureInfo& texture, const FramebufferInfo& framebuffer_info);
     void DrawScreens();
     void DrawSingleScreen(const ScreenInfo& screen_info, float x, float y, float w, float h);
     void UpdateFramerate();
 
     // Loads framebuffer from emulated memory into the display information structure
-    void LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer, ScreenInfo& screen_info);
+    void LoadFBToScreenInfo(const FramebufferInfo& framebuffer_info, 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);
@@ -88,6 +87,6 @@ private:
     GLuint attrib_position;
     GLuint attrib_tex_coord;
 
-    /// Used for transforming the framebuffer orientation
-    Tegra::FramebufferConfig::TransformFlags framebuffer_transform_flags;
+    /// Flips the framebuffer vertically when true
+    bool framebuffer_flip_vertical;
 };

src/video_core/utils.h

@@ -49,116 +49,4 @@ static inline u32 GetMortonOffset(u32 x, u32 y, u32 bytes_per_pixel) {
     return (i + offset) * bytes_per_pixel;
 }
 
-static inline u32 MortonInterleave128(u32 x, u32 y) {
-    // 128x128 Z-Order coordinate from 2D coordinates
-    static constexpr u32 xlut[] = {
-        0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042,
-        0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809,
-        0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000,
-        0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043,
-        0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a,
-        0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001,
-        0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048,
-        0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b,
-        0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002,
-        0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049,
-        0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840,
-        0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003,
-        0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a,
-        0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841,
-        0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008,
-        0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b,
-        0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842,
-        0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009,
-        0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800,
-        0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843,
-        0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a,
-        0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801,
-        0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848,
-        0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b,
-        0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802,
-        0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849,
-        0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040,
-        0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803,
-        0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a,
-        0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041,
-        0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808,
-        0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b,
-        0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042,
-        0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809,
-        0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b,
-    };
-    static constexpr u32 ylut[] = {
-        0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090,
-        0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124,
-        0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200,
-        0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294,
-        0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330,
-        0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404,
-        0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0,
-        0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534,
-        0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610,
-        0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4,
-        0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780,
-        0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014,
-        0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0,
-        0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184,
-        0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220,
-        0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4,
-        0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390,
-        0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424,
-        0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500,
-        0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594,
-        0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630,
-        0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704,
-        0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0,
-        0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034,
-        0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110,
-        0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4,
-        0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280,
-        0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314,
-        0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0,
-        0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484,
-        0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520,
-        0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4,
-        0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690,
-        0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724,
-        0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4,
-    };
-    return xlut[x % 128] + ylut[y % 128];
-}
-
-static inline u32 GetMortonOffset128(u32 x, u32 y, u32 bytes_per_pixel) {
-    // Calculates the offset of the position of the pixel in Morton order
-    // Framebuffer images are split into 128x128 tiles.
-
-    const unsigned int block_height = 128;
-    const unsigned int coarse_x = x & ~127;
-
-    u32 i = MortonInterleave128(x, y);
-
-    const unsigned int offset = coarse_x * block_height;
-
-    return (i + offset) * bytes_per_pixel;
-}
-
-static inline void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixel,
-                                       u32 gl_bytes_per_pixel, u8* morton_data, u8* gl_data,
-                                       bool morton_to_gl) {
-    u8* data_ptrs[2];
-    for (unsigned y = 0; y < height; ++y) {
-        for (unsigned x = 0; x < width; ++x) {
-            const u32 coarse_y = y & ~127;
-            u32 morton_offset =
-                GetMortonOffset128(x, y, bytes_per_pixel) + coarse_y * width * bytes_per_pixel;
-            u32 gl_pixel_index = (x + (height - 1 - y) * width) * gl_bytes_per_pixel;
-
-            data_ptrs[morton_to_gl] = morton_data + morton_offset;
-            data_ptrs[!morton_to_gl] = &gl_data[gl_pixel_index];
-
-            memcpy(data_ptrs[0], data_ptrs[1], bytes_per_pixel);
-        }
-    }
-}
-
 } // namespace VideoCore

src/video_core/video_core.h

@@ -15,8 +15,6 @@ class RendererBase;
 
 namespace VideoCore {
 
-enum class Renderer { Software, OpenGL };
-
 extern std::unique_ptr<RendererBase> g_renderer; ///< Renderer plugin
 extern EmuWindow* g_emu_window;                  ///< Emu window
 

src/yuzu/main.cpp

@@ -18,6 +18,7 @@
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
 #include "common/microprofile.h"
+#include "common/platform.h"
 #include "common/scm_rev.h"
 #include "common/scope_exit.h"
 #include "common/string_util.h"