yuzu_cmd: change default cpu core to dynarmic

Remove more N3DS References

.gitmodules

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

CMakeLists.txt

@@ -160,6 +160,9 @@ 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,gles=3.0
+python -m glad --profile core --out-path glad/ --api gl=3.3 --generator=c
 ```

externals/glad/include/KHR/khrplatform.h

@@ -26,7 +26,7 @@
 
 /* Khronos platform-specific types and definitions.
  *
- * $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
+ * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
  *
  * Adopters may modify this file to suit their platform. Adopters are
  * encouraged to submit platform specific modifications to the Khronos
@@ -101,6 +101,8 @@
 #   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
@@ -223,7 +225,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,7 +58,6 @@ 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,6 +37,7 @@ namespace Log {
     SUB(Service, AM)                                                                               \
     SUB(Service, AOC)                                                                              \
     SUB(Service, APM)                                                                              \
+    SUB(Service, Fatal)                                                                            \
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \
@@ -47,6 +48,7 @@ namespace Log {
     SUB(Service, PCTL)                                                                             \
     SUB(Service, SET)                                                                              \
     SUB(Service, SM)                                                                               \
+    SUB(Service, SPL)                                                                              \
     SUB(Service, Time)                                                                             \
     SUB(Service, VI)                                                                               \
     CLS(HW)                                                                                        \

src/common/logging/log.h

@@ -54,6 +54,7 @@ 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
@@ -64,6 +65,7 @@ enum class Class : ClassType {
     Service_PCTL,      ///< The PCTL (Parental control) service
     Service_SET,       ///< The SET (Settings) service
     Service_SM,        ///< The SM (Service manager) service
+    Service_SPL,       ///< The SPL service
     Service_Time,      ///< The time service
     Service_VI,        ///< The VI (Video interface) service
     HW,                ///< Low-level hardware emulation

src/common/platform.h

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

@@ -114,6 +114,12 @@ 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
@@ -187,6 +193,12 @@ add_library(core STATIC
     hle/service/sockets/sfdnsres.h
     hle/service/sockets/sockets.cpp
     hle/service/sockets/sockets.h
+    hle/service/spl/csrng.cpp
+    hle/service/spl/csrng.h
+    hle/service/spl/module.cpp
+    hle/service/spl/module.h
+    hle/service/spl/spl.cpp
+    hle/service/spl/spl.h
     hle/service/time/time.cpp
     hle/service/time/time.h
     hle/service/time/time_s.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%llx, pc=0x%llx, lr=0x%llx", addr,
+    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x%lx, pc=0x%lx, lr=0x%lx", addr,
                ctx.pc, ctx.cpu_registers[30]);
     return {};
 }

src/core/core.cpp

@@ -99,14 +99,15 @@ 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)!", init_result);
+        LOG_CRITICAL(Core, "Failed to initialize system (Error %i)!",
+                     static_cast<int>(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)!", load_result);
+        LOG_CRITICAL(Core, "Failed to load ROM (Error %i)!", static_cast<int>(load_result));
         System::Shutdown();
 
         switch (load_result) {

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: %016llx len: %016llx\n", addr, len);
+    LOG_DEBUG(Debug_GDBStub, "gdb: addr: %016lx len: %016lx\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 %d is too big", size);
+    ASSERT_MSG(size <= GetWriteBufferSize(), "Size %lx 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%llx", addr);
+    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x%lx", addr);
     objects[addr] = obj;
 }
 
 void ObjectAddressTable::Close(VAddr addr) {
-    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x%llx", addr);
+    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x%lx", addr);
     objects.erase(addr);
 }
 

src/core/hle/kernel/server_session.cpp

@@ -78,7 +78,8 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
         }
         }
 
-        LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
+        LOG_CRITICAL(IPC, "Unknown domain command=%d",
+                     static_cast<int>(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%llx name=%s, permissions don't match",
+        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx 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%llx name=%s, permissions don't match",
+        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx 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%llx name=%s, invalid address",
+            LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, invalid address",
                       GetObjectId(), address, name.c_str());
             return ERR_INVALID_ADDRESS;
         }
@@ -143,10 +143,9 @@ 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%llx name=%s, error mapping to virtual memory",
-            GetObjectId(), target_address, name.c_str());
+        LOG_ERROR(Kernel,
+                  "cannot map id=%u, target_address=0x%lx 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%llx", addr);
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x%lx", 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%llx, size=0x%llx, perms=%08X", addr, size,
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x%lx, size=0x%lx, perms=%08X", addr, size,
                 permissions);
     *handle = 0;
     return RESULT_SUCCESS;

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+// 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/fsp_srv.cpp

@@ -35,7 +35,7 @@ private:
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
+        LOG_DEBUG(Service_FS, "called, offset=0x%ld, length=0x%ld", offset, length);
 
         // Error checking
         if (length < 0) {
@@ -86,7 +86,7 @@ private:
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
+        LOG_DEBUG(Service_FS, "called, offset=0x%ld, length=0x%ld", offset, length);
 
         // Error checking
         if (length < 0) {
@@ -123,7 +123,7 @@ private:
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
+        LOG_DEBUG(Service_FS, "called, offset=0x%ld, length=0x%ld", offset, length);
 
         // Error checking
         if (length < 0) {

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

@@ -23,8 +23,8 @@ 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 %llx offset %08X Width %u Height %u Stride %u Format %u",
-                addr, offset, width, height, stride, format);
+                "Drawing from address %lx offset %08X Width %u Height %u Stride %u Format %u", addr,
+                offset, width, height, stride, format);
 
     using PixelFormat = RendererBase::FramebufferInfo::PixelFormat;
     using Flags = NVFlinger::BufferQueue::BufferTransformFlags;

src/core/hle/service/service.cpp

@@ -20,6 +20,7 @@
 #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"
@@ -33,6 +34,7 @@
 #include "core/hle/service/sm/controller.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/sockets/sockets.h"
+#include "core/hle/service/spl/module.h"
 #include "core/hle/service/time/time.h"
 #include "core/hle/service/vi/vi.h"
 
@@ -149,7 +151,7 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
         break;
     }
     default:
-        UNIMPLEMENTED_MSG("command_type=%d", context.GetCommandType());
+        UNIMPLEMENTED_MSG("command_type=%d", static_cast<int>(context.GetCommandType()));
     }
 
     context.WriteToOutgoingCommandBuffer(*Kernel::GetCurrentThread());
@@ -179,6 +181,7 @@ 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);
@@ -188,6 +191,7 @@ void Init() {
     Nvidia::InstallInterfaces(*SM::g_service_manager);
     PCTL::InstallInterfaces(*SM::g_service_manager);
     Sockets::InstallInterfaces(*SM::g_service_manager);
+    SPL::InstallInterfaces(*SM::g_service_manager);
     Time::InstallInterfaces(*SM::g_service_manager);
     VI::InstallInterfaces(*SM::g_service_manager, nv_flinger);
     Set::InstallInterfaces(*SM::g_service_manager);

src/core/hle/service/spl/csrng.cpp

@@ -0,0 +1,18 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/spl/csrng.h"
+
+namespace Service {
+namespace SPL {
+
+CSRNG::CSRNG(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "csrng") {
+    static const FunctionInfo functions[] = {
+        {0, &CSRNG::GetRandomBytes, "GetRandomBytes"},
+    };
+    RegisterHandlers(functions);
+}
+
+} // namespace SPL
+} // namespace Service

src/core/hle/service/spl/csrng.h

@@ -0,0 +1,18 @@
+// 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/spl/module.h"
+
+namespace Service {
+namespace SPL {
+
+class CSRNG final : public Module::Interface {
+public:
+    explicit CSRNG(std::shared_ptr<Module> module);
+};
+
+} // namespace SPL
+} // namespace Service

src/core/hle/service/spl/module.cpp

@@ -0,0 +1,42 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <cstdlib>
+#include <vector>
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/spl/csrng.h"
+#include "core/hle/service/spl/module.h"
+#include "core/hle/service/spl/spl.h"
+
+namespace Service {
+namespace SPL {
+
+Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
+    : ServiceFramework(name), module(std::move(module)) {}
+
+void Module::Interface::GetRandomBytes(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+
+    size_t size = ctx.GetWriteBufferSize();
+
+    std::vector<u8> data(size);
+    std::generate(data.begin(), data.end(), std::rand);
+
+    ctx.WriteBuffer(data);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_DEBUG(Service_SPL, "called");
+}
+
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    auto module = std::make_shared<Module>();
+    std::make_shared<CSRNG>(module)->InstallAsService(service_manager);
+    std::make_shared<SPL>(module)->InstallAsService(service_manager);
+}
+
+} // namespace SPL
+} // namespace Service

src/core/hle/service/spl/module.h

@@ -0,0 +1,29 @@
+// 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 SPL {
+
+class Module final {
+public:
+    class Interface : public ServiceFramework<Interface> {
+    public:
+        Interface(std::shared_ptr<Module> module, const char* name);
+
+        void GetRandomBytes(Kernel::HLERequestContext& ctx);
+
+    protected:
+        std::shared_ptr<Module> module;
+    };
+};
+
+/// Registers all SPL services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
+} // namespace SPL
+} // namespace Service

src/core/hle/service/spl/spl.cpp

@@ -0,0 +1,41 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/spl/spl.h"
+
+namespace Service {
+namespace SPL {
+
+SPL::SPL(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "spl:") {
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetConfig"},
+        {1, nullptr, "UserExpMod"},
+        {2, nullptr, "GenerateAesKek"},
+        {3, nullptr, "LoadAesKey"},
+        {4, nullptr, "GenerateAesKey"},
+        {5, nullptr, "SetConfig"},
+        {7, &SPL::GetRandomBytes, "GetRandomBytes"},
+        {9, nullptr, "LoadSecureExpModKey"},
+        {10, nullptr, "SecureExpMod"},
+        {11, nullptr, "IsDevelopment"},
+        {12, nullptr, "GenerateSpecificAesKey"},
+        {13, nullptr, "DecryptPrivk"},
+        {14, nullptr, "DecryptAesKey"},
+        {15, nullptr, "DecryptAesCtr"},
+        {16, nullptr, "ComputeCmac"},
+        {17, nullptr, "LoadRsaOaepKey"},
+        {18, nullptr, "UnwrapRsaOaepWrappedTitleKey"},
+        {19, nullptr, "LoadTitleKey"},
+        {20, nullptr, "UnwrapAesWrappedTitleKey"},
+        {21, nullptr, "LockAesEngine"},
+        {22, nullptr, "UnlockAesEngine"},
+        {23, nullptr, "GetSplWaitEvent"},
+        {24, nullptr, "SetSharedData"},
+        {25, nullptr, "GetSharedData"},
+    };
+    RegisterHandlers(functions);
+}
+
+} // namespace SPL
+} // namespace Service

src/core/hle/service/spl/spl.h

@@ -0,0 +1,18 @@
+// 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/spl/module.h"
+
+namespace Service {
+namespace SPL {
+
+class SPL final : public Module::Interface {
+public:
+    explicit SPL(std::shared_ptr<Module> module);
+};
+
+} // namespace SPL
+} // namespace Service

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%016llX", posix_time);
+        LOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x%016lX", posix_time);
 
         CalendarTime calendar_time{2018, 1, 1, 0, 0, 0};
         CalendarAdditionalInfo additional_info{};

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

@@ -4,10 +4,13 @@
 
 #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"
@@ -471,7 +474,7 @@ private:
         u32 flags = rp.Pop<u32>();
         auto buffer_queue = nv_flinger->GetBufferQueue(id);
 
-        LOG_DEBUG(Service_VI, "called, transaction=%x", transaction);
+        LOG_DEBUG(Service_VI, "called, transaction=%x", static_cast<u32>(transaction));
 
         if (transaction == TransactionId::Connect) {
             IGBPConnectRequestParcel request{ctx.ReadBuffer()};
@@ -646,144 +649,152 @@ private:
     std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
-void IApplicationDisplayService::GetRelayService(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
+public:
+    IApplicationDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    ~IApplicationDisplayService() = default;
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
-}
+private:
+    void GetRelayService(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_VI, "(STUBBED) called");
 
-void IApplicationDisplayService::GetSystemDisplayService(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<ISystemDisplayService>();
-}
+    void GetSystemDisplayService(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_VI, "(STUBBED) called");
 
-void IApplicationDisplayService::GetManagerDisplayService(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<IManagerDisplayService>(nv_flinger);
-}
+    void GetManagerDisplayService(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_VI, "(STUBBED) called");
 
-void IApplicationDisplayService::GetIndirectDisplayTransactionService(
-    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<IHOSBinderDriver>(nv_flinger);
-}
+    void GetIndirectDisplayTransactionService(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_VI, "(STUBBED) called");
 
-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');
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
+    }
 
-    std::string name(name_buf.begin(), end);
+    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');
 
-    ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
+        std::string name(name_buf.begin(), end);
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(nv_flinger->OpenDisplay(name));
-}
+        ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
 
-void IApplicationDisplayService::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(4, 0, 0);
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u64>(nv_flinger->OpenDisplay(name));
+    }
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
-    rb.Push(RESULT_SUCCESS);
-}
+    void CloseDisplay(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_VI, "(STUBBED) called");
+        IPC::RequestParser rp{ctx};
+        u64 display_id = rp.Pop<u64>();
 
-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');
+        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+        rb.Push(RESULT_SUCCESS);
+    }
 
-    std::string display_name(name_buf.begin(), end);
+    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>();
 
-    u64 layer_id = rp.Pop<u64>();
-    u64 aruid = rp.Pop<u64>();
+        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+        rb.Push(RESULT_SUCCESS);
+    }
 
-    u64 display_id = nv_flinger->OpenDisplay(display_name);
-    u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
+    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");
+    }
 
-    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()));
-}
+    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');
 
-void IApplicationDisplayService::CreateStrayLayer(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_VI, "called");
+        std::string display_name(name_buf.begin(), end);
 
-    IPC::RequestParser rp{ctx};
-    u32 flags = rp.Pop<u32>();
-    rp.Pop<u32>(); // padding
-    u64 display_id = rp.Pop<u64>();
+        u64 layer_id = rp.Pop<u64>();
+        u64 aruid = rp.Pop<u64>();
 
-    // TODO(Subv): What's the difference between a Stray and a Managed layer?
+        u64 display_id = nv_flinger->OpenDisplay(display_name);
+        u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
 
-    u64 layer_id = nv_flinger->CreateLayer(display_id);
-    u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
+        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()));
+    }
 
-    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 CreateStrayLayer(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_VI, "called");
 
-void IApplicationDisplayService::DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+        IPC::RequestParser rp{ctx};
+        u32 flags = rp.Pop<u32>();
+        rp.Pop<u32>(); // padding
+        u64 display_id = rp.Pop<u64>();
 
-    IPC::RequestParser rp{ctx};
-    u64 layer_id = rp.Pop<u64>();
+        // TODO(Subv): What's the difference between a Stray and a Managed layer?
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
-    rb.Push(RESULT_SUCCESS);
-}
+        u64 layer_id = nv_flinger->CreateLayer(display_id);
+        u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
 
-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>();
+        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::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
-    rb.Push(RESULT_SUCCESS);
-}
+    void DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_VI, "(STUBBED) called");
 
-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::RequestParser rp{ctx};
+        u64 layer_id = rp.Pop<u64>();
 
-void IApplicationDisplayService::GetDisplayVsyncEvent(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);
+    }
 
-    auto vsync_event = nv_flinger->GetVsyncEvent(display_id);
+    void GetDisplayVsyncEvent(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, 1, 0);
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(vsync_event);
-}
+        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;
+};
 
 IApplicationDisplayService::IApplicationDisplayService(
     std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
@@ -806,11 +817,24 @@ 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) {
-    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);
+    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);
 }
 
 } // namespace VI

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

@@ -4,9 +4,6 @@
 
 #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"
 
@@ -17,26 +14,19 @@ struct EventType;
 namespace Service {
 namespace VI {
 
-class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
+class Module final {
 public:
-    IApplicationDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
-    ~IApplicationDisplayService() = default;
+    class Interface : public ServiceFramework<Interface> {
+    public:
+        Interface(std::shared_ptr<Module> module, const char* name,
+                  std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
 
-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);
+        void GetDisplayService(Kernel::HLERequestContext& ctx);
 
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
+    protected:
+        std::shared_ptr<Module> module;
+        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,24 +2,13 @@
 // 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 {
 
-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)) {
+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)) {
     static const FunctionInfo functions[] = {
         {2, &VI_M::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

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

@@ -4,25 +4,14 @@
 
 #pragma once
 
-#include <memory>
-#include "core/hle/service/service.h"
+#include "core/hle/service/vi/vi.h"
 
 namespace Service {
-namespace NVFlinger {
-class NVFlinger;
-}
-
 namespace VI {
 
-class VI_M final : public ServiceFramework<VI_M> {
+class VI_M final : public Module::Interface {
 public:
-    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;
+    explicit VI_M(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
 };
 
 } // namespace VI

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

@@ -2,24 +2,13 @@
 // 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 {
 
-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)) {
+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)) {
     static const FunctionInfo functions[] = {
         {1, &VI_S::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

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

@@ -4,25 +4,14 @@
 
 #pragma once
 
-#include <memory>
-#include "core/hle/service/service.h"
+#include "core/hle/service/vi/vi.h"
 
 namespace Service {
-namespace NVFlinger {
-class NVFlinger;
-}
-
 namespace VI {
 
-class VI_S final : public ServiceFramework<VI_S> {
+class VI_S final : public Module::Interface {
 public:
-    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;
+    explicit VI_S(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
 };
 
 } // namespace VI

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

@@ -2,24 +2,13 @@
 // 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 {
 
-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)) {
+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)) {
     static const FunctionInfo functions[] = {
         {0, &VI_U::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

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

@@ -4,25 +4,14 @@
 
 #pragma once
 
-#include <memory>
-#include "core/hle/service/service.h"
+#include "core/hle/service/vi/vi.h"
 
 namespace Service {
-namespace NVFlinger {
-class NVFlinger;
-}
-
 namespace VI {
 
-class VI_U final : public ServiceFramework<VI_U> {
+class VI_U final : public Module::Interface {
 public:
-    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;
+    explicit VI_U(std::shared_ptr<Module> module, 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", rela.type);
+            LOG_CRITICAL(Loader, "Unknown relocation type: %d", static_cast<int>(rela.type));
             break;
         }
     }

src/core/memory.cpp

@@ -23,7 +23,6 @@
 namespace Memory {
 
 static std::array<u8, Memory::VRAM_SIZE> vram;
-static std::array<u8, Memory::N3DS_EXTRA_RAM_SIZE> n3ds_extra_ram;
 
 static PageTable* current_page_table = nullptr;
 
@@ -244,7 +243,6 @@ u8* GetPhysicalPointer(PAddr address) {
         {IO_AREA_PADDR, IO_AREA_SIZE},
         {DSP_RAM_PADDR, DSP_RAM_SIZE},
         {FCRAM_PADDR, FCRAM_N3DS_SIZE},
-        {N3DS_EXTRA_RAM_PADDR, N3DS_EXTRA_RAM_SIZE},
     };
 
     const auto area =
@@ -283,9 +281,6 @@ u8* GetPhysicalPointer(PAddr address) {
         }
         ASSERT_MSG(target_pointer != nullptr, "Invalid FCRAM address");
         break;
-    case N3DS_EXTRA_RAM_PADDR:
-        target_pointer = n3ds_extra_ram.data() + offset_into_region;
-        break;
     default:
         UNREACHABLE();
     }
@@ -609,8 +604,6 @@ boost::optional<PAddr> TryVirtualToPhysicalAddress(const VAddr addr) {
         return addr - DSP_RAM_VADDR + DSP_RAM_PADDR;
     } else if (addr >= IO_AREA_VADDR && addr < IO_AREA_VADDR_END) {
         return addr - IO_AREA_VADDR + IO_AREA_PADDR;
-    } else if (addr >= N3DS_EXTRA_RAM_VADDR && addr < N3DS_EXTRA_RAM_VADDR_END) {
-        return addr - N3DS_EXTRA_RAM_VADDR + N3DS_EXTRA_RAM_PADDR;
     }
 
     return boost::none;
@@ -637,8 +630,6 @@ boost::optional<VAddr> PhysicalToVirtualAddress(const PAddr addr) {
         return addr - DSP_RAM_PADDR + DSP_RAM_VADDR;
     } else if (addr >= IO_AREA_PADDR && addr < IO_AREA_PADDR_END) {
         return addr - IO_AREA_PADDR + IO_AREA_VADDR;
-    } else if (addr >= N3DS_EXTRA_RAM_PADDR && addr < N3DS_EXTRA_RAM_PADDR_END) {
-        return addr - N3DS_EXTRA_RAM_PADDR + N3DS_EXTRA_RAM_VADDR;
     }
 
     return boost::none;

src/core/memory.h

@@ -98,12 +98,6 @@ enum : PAddr {
     VRAM_SIZE = 0x00600000, ///< VRAM size (6MB)
     VRAM_PADDR_END = VRAM_PADDR + VRAM_SIZE,
 
-    /// New 3DS additional memory. Supposedly faster than regular FCRAM. Part of it can be used by
-    /// applications and system modules if mapped via the ExHeader.
-    N3DS_EXTRA_RAM_PADDR = 0x1F000000,
-    N3DS_EXTRA_RAM_SIZE = 0x00400000, ///< New 3DS additional memory size (4MB)
-    N3DS_EXTRA_RAM_PADDR_END = N3DS_EXTRA_RAM_PADDR + N3DS_EXTRA_RAM_SIZE,
-
     /// DSP memory
     DSP_RAM_PADDR = 0x1FF00000,
     DSP_RAM_SIZE = 0x00080000, ///< DSP memory size (512KB)
@@ -119,7 +113,6 @@ enum : PAddr {
     FCRAM_SIZE = 0x08000000,      ///< FCRAM size on the Old 3DS (128MB)
     FCRAM_N3DS_SIZE = 0x10000000, ///< FCRAM size on the New 3DS (256MB)
     FCRAM_PADDR_END = FCRAM_PADDR + FCRAM_SIZE,
-    FCRAM_N3DS_PADDR_END = FCRAM_PADDR + FCRAM_N3DS_SIZE,
 };
 
 /// Virtual user-space memory regions
@@ -135,10 +128,6 @@ enum : VAddr {
     LINEAR_HEAP_SIZE = 0x08000000,
     LINEAR_HEAP_VADDR_END = LINEAR_HEAP_VADDR + LINEAR_HEAP_SIZE,
 
-    /// Maps 1:1 to New 3DS additional memory
-    N3DS_EXTRA_RAM_VADDR = 0x1E800000,
-    N3DS_EXTRA_RAM_VADDR_END = N3DS_EXTRA_RAM_VADDR + N3DS_EXTRA_RAM_SIZE,
-
     /// Maps 1:1 to the IO register area.
     IO_AREA_VADDR = 0x1EC00000,
     IO_AREA_VADDR_END = IO_AREA_VADDR + IO_AREA_SIZE,

src/video_core/CMakeLists.txt

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

src/video_core/engines/maxwell_3d.h

@@ -34,6 +34,7 @@ public:
         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.
@@ -83,7 +84,14 @@ public:
                     }
                 } rt[NumRenderTargets];
 
-                INSERT_PADDING_WORDS(0x178);
+                INSERT_PADDING_WORDS(0xDD);
+
+                struct {
+                    u32 first;
+                    u32 count;
+                } vertex_buffer;
+
+                INSERT_PADDING_WORDS(0x99);
 
                 struct {
                     u32 address_high;
@@ -98,7 +106,18 @@ public:
                     }
                 } zeta;
 
-                INSERT_PADDING_WORDS(0x8A);
+                INSERT_PADDING_WORDS(0x5B);
+
+                union {
+                    BitField<0, 5, u32> buffer;
+                    BitField<6, 1, u32> constant;
+                    BitField<7, 14, u32> offset;
+                    BitField<21, 6, u32> size;
+                    BitField<27, 3, u32> type;
+                    BitField<31, 1, u32> bgra;
+                } vertex_attrib_format[NumVertexAttributes];
+
+                INSERT_PADDING_WORDS(0xF);
 
                 struct {
                     union {
@@ -146,7 +165,10 @@ public:
                 INSERT_PADDING_WORDS(1);
                 struct {
                     u32 vertex_end_gl;
-                    u32 vertex_begin_gl;
+                    union {
+                        u32 vertex_begin_gl;
+                        BitField<0, 16, u32> topology;
+                    };
                 } draw;
                 INSERT_PADDING_WORDS(0x139);
                 struct {
@@ -336,7 +358,9 @@ private:
                   "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);

src/video_core/rasterizer_interface.h

@@ -0,0 +1,61 @@
+// 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"
+
+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(PAddr addr, u32 size) = 0;
+
+    /// Notify rasterizer that any caches of the specified region should be invalidated
+    virtual void InvalidateRegion(PAddr addr, u32 size) = 0;
+
+    /// Notify rasterizer that any caches of the specified region should be flushed to 3DS memory
+    /// and invalidated
+    virtual void FlushAndInvalidateRegion(PAddr addr, u32 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 void* config, PAddr framebuffer_addr, u32 pixel_stride,
+                                   ScreenInfo& screen_info) {
+        return false;
+    }
+
+    virtual bool AccelerateDrawBatch(bool is_indexed) {
+        return false;
+    }
+};
+} // namespace VideoCore

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -0,0 +1,269 @@
+// 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() {
+    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();
+        vs_input_index_min = 0;
+        vs_input_index_max = 0;
+        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 {
+        UNIMPLEMENTED();
+    }
+
+    accelerate_draw = AccelDraw::Disabled;
+
+    glEnable(GL_BLEND);
+
+    // Sync fixed function OpenGL state
+    SyncClipEnabled();
+    SyncClipCoef();
+    SyncCullMode();
+    SyncBlendEnabled();
+    SyncBlendFuncs();
+    SyncBlendColor();
+}
+
+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);
+    UNIMPLEMENTED();
+}
+
+bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
+    if (!has_ARB_separate_shader_objects) {
+        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(PAddr addr, u32 size) {
+    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
+    res_cache.FlushRegion(addr, size);
+}
+
+void RasterizerOpenGL::InvalidateRegion(PAddr addr, u32 size) {
+    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
+    res_cache.InvalidateRegion(addr, size, nullptr);
+}
+
+void RasterizerOpenGL::FlushAndInvalidateRegion(PAddr addr, u32 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);
+    UNIMPLEMENTED();
+    return true;
+}
+
+bool RasterizerOpenGL::AccelerateTextureCopy(const void* config) {
+    UNIMPLEMENTED();
+    return true;
+}
+
+bool RasterizerOpenGL::AccelerateFill(const void* config) {
+    UNIMPLEMENTED();
+    return true;
+}
+
+bool RasterizerOpenGL::AccelerateDisplay(const void* config, PAddr framebuffer_addr,
+                                         u32 pixel_stride, ScreenInfo& screen_info) {
+    UNIMPLEMENTED();
+    return true;
+}
+
+void RasterizerOpenGL::SetShader() {
+    UNIMPLEMENTED();
+}
+
+void RasterizerOpenGL::SyncClipEnabled() {
+    UNIMPLEMENTED();
+}
+
+void RasterizerOpenGL::SyncClipCoef() {
+    UNIMPLEMENTED();
+}
+
+void RasterizerOpenGL::SyncCullMode() {
+    UNIMPLEMENTED();
+}
+
+void RasterizerOpenGL::SyncDepthScale() {
+    UNIMPLEMENTED();
+}
+
+void RasterizerOpenGL::SyncDepthOffset() {
+    UNIMPLEMENTED();
+}
+
+void RasterizerOpenGL::SyncBlendEnabled() {
+    UNIMPLEMENTED();
+}
+
+void RasterizerOpenGL::SyncBlendFuncs() {
+    UNIMPLEMENTED();
+}
+
+void RasterizerOpenGL::SyncBlendColor() {
+    UNIMPLEMENTED();
+}

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -0,0 +1,162 @@
+// 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(PAddr addr, u32 size) override;
+    void InvalidateRegion(PAddr addr, u32 size) override;
+    void FlushAndInvalidateRegion(PAddr addr, u32 size) override;
+    bool AccelerateDisplayTransfer(const void* config) override;
+    bool AccelerateTextureCopy(const void* config) override;
+    bool AccelerateFill(const void* config) override;
+    bool AccelerateDisplay(const void* config, PAddr framebuffer_addr, u32 pixel_stride,
+                           ScreenInfo& screen_info) override;
+    bool AccelerateDrawBatch(bool is_indexed) override;
+
+    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;
+
+    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;
+
+    GLint vs_input_index_min;
+    GLint vs_input_index_max;
+    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

@@ -0,0 +1,350 @@
+// 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/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<PAddr>;
+using SurfaceMap = boost::icl::interval_map<PAddr, Surface>;
+using SurfaceCache = boost::icl::interval_map<PAddr, 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 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;
+
+    PAddr addr = 0;
+    PAddr 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 3DS memory to/from gl_buffer
+    void LoadGLBuffer(PAddr load_start, PAddr load_end);
+    void FlushGLBuffer(PAddr flush_start, PAddr 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(PAddr addr, u64 size, Surface flush_surface = nullptr);
+
+    /// Mark region as being invalidated by region_owner (nullptr if 3DS memory)
+    void InvalidateRegion(PAddr 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, PAddr 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(PAddr 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::ResetTexture(handle);
+        OpenGLState::GetCurState().ResetTexture(handle).Apply();
         handle = 0;
     }
 
@@ -69,7 +69,7 @@ public:
         if (handle == 0)
             return;
         glDeleteSamplers(1, &handle);
-        OpenGLState::ResetSampler(handle);
+        OpenGLState::GetCurState().ResetSampler(handle).Apply();
         handle = 0;
     }
 
@@ -91,10 +91,13 @@ public:
     }
 
     /// Creates a new internal OpenGL resource and stores the handle
-    void Create(const char* vert_shader, const char* frag_shader) {
+    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) {
         if (handle != 0)
             return;
-        handle = GLShader::LoadProgram(vert_shader, frag_shader);
+        handle = GLShader::LoadProgram(vert_shader, geo_shader, frag_shader, feedback_vars,
+                                       separable_program);
     }
 
     /// Deletes the internal OpenGL resource
@@ -102,7 +105,40 @@ public:
         if (handle == 0)
             return;
         glDeleteProgram(handle);
-        OpenGLState::ResetProgram(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();
         handle = 0;
     }
 
@@ -135,13 +171,46 @@ public:
         if (handle == 0)
             return;
         glDeleteBuffers(1, &handle);
-        OpenGLState::ResetBuffer(handle);
+        OpenGLState::GetCurState().ResetBuffer(handle).Apply();
         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;
@@ -168,7 +237,7 @@ public:
         if (handle == 0)
             return;
         glDeleteVertexArrays(1, &handle);
-        OpenGLState::ResetVertexArray(handle);
+        OpenGLState::GetCurState().ResetVertexArray(handle).Apply();
         handle = 0;
     }
 
@@ -201,7 +270,7 @@ public:
         if (handle == 0)
             return;
         glDeleteFramebuffers(1, &handle);
-        OpenGLState::ResetFramebuffer(handle);
+        OpenGLState::GetCurState().ResetFramebuffer(handle).Apply();
         handle = 0;
     }
 

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

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

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

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

@@ -0,0 +1,66 @@
+// 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,53 +10,85 @@
 
 namespace GLShader {
 
-GLuint LoadProgram(const char* vertex_shader, const char* fragment_shader) {
-
+GLuint LoadProgram(const char* vertex_shader, const char* geometry_shader,
+                   const char* fragment_shader, const std::vector<const char*>& feedback_vars,
+                   bool separable_program) {
     // Create the shaders
-    GLuint vertex_shader_id = glCreateShader(GL_VERTEX_SHADER);
-    GLuint fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER);
+    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;
 
     GLint result = GL_FALSE;
     int info_log_length;
 
-    // Compile Vertex Shader
-    LOG_DEBUG(Render_OpenGL, "Compiling vertex shader...");
+    if (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]);
+            }
         }
     }
 
-    // Compile Fragment Shader
-    LOG_DEBUG(Render_OpenGL, "Compiling fragment shader...");
+    if (geometry_shader) {
+        // Compile Geometry Shader
+        LOG_DEBUG(Render_OpenGL, "Compiling geometry shader...");
 
-    glShaderSource(fragment_shader_id, 1, &fragment_shader, nullptr);
-    glCompileShader(fragment_shader_id);
+        glShaderSource(geometry_shader_id, 1, &geometry_shader, nullptr);
+        glCompileShader(geometry_shader_id);
 
-    // Check Fragment Shader
-    glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS, &result);
-    glGetShaderiv(fragment_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
+        // Check Geometry Shader
+        glGetShaderiv(geometry_shader_id, GL_COMPILE_STATUS, &result);
+        glGetShaderiv(geometry_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> 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]);
+            }
         }
     }
 
@@ -64,8 +96,25 @@ GLuint LoadProgram(const char* vertex_shader, const char* fragment_shader) {
     LOG_DEBUG(Render_OpenGL, "Linking program...");
 
     GLuint program_id = glCreateProgram();
-    glAttachShader(program_id, vertex_shader_id);
-    glAttachShader(program_id, fragment_shader_id);
+    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);
+    }
 
     glLinkProgram(program_id);
 
@@ -85,13 +134,30 @@ GLuint LoadProgram(const char* vertex_shader, const char* fragment_shader) {
 
     // If the program linking failed at least one of the shaders was probably bad
     if (result == GL_FALSE) {
-        LOG_ERROR(Render_OpenGL, "Vertex shader:\n%s", vertex_shader);
-        LOG_ERROR(Render_OpenGL, "Fragment shader:\n%s", fragment_shader);
+        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);
+        }
     }
     ASSERT_MSG(result == GL_TRUE, "Shader not linked");
 
-    glDeleteShader(vertex_shader_id);
-    glDeleteShader(fragment_shader_id);
+    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);
+    }
 
     return program_id;
 }

src/video_core/renderer_opengl/gl_shader_util.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <vector>
 #include <glad/glad.h>
 
 namespace GLShader {
@@ -11,9 +12,12 @@ 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* fragment_shader);
+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);
 
 } // 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 = false;
+    blend.enabled = true;
     blend.rgb_equation = GL_FUNC_ADD;
     blend.a_equation = GL_FUNC_ADD;
     blend.src_rgb_func = GL_ONE;
@@ -68,6 +68,18 @@ 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 = {};
 }
@@ -148,9 +160,6 @@ 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);
@@ -196,7 +205,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, cur_state.lighting_lut.texture_buffer);
+        glBindTexture(GL_TEXTURE_BUFFER, lighting_lut.texture_buffer);
     }
 
     // Fog LUT
@@ -263,6 +272,31 @@ 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]) {
@@ -277,62 +311,75 @@ void OpenGLState::Apply() const {
     cur_state = *this;
 }
 
-void OpenGLState::ResetTexture(GLuint handle) {
-    for (auto& unit : cur_state.texture_units) {
+OpenGLState& OpenGLState::ResetTexture(GLuint handle) {
+    for (auto& unit : texture_units) {
         if (unit.texture_2d == handle) {
             unit.texture_2d = 0;
         }
     }
-    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;
+    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;
 }
 
-void OpenGLState::ResetSampler(GLuint handle) {
-    for (auto& unit : cur_state.texture_units) {
+OpenGLState& OpenGLState::ResetSampler(GLuint handle) {
+    for (auto& unit : texture_units) {
         if (unit.sampler == handle) {
             unit.sampler = 0;
         }
     }
+    return *this;
 }
 
-void OpenGLState::ResetProgram(GLuint handle) {
-    if (cur_state.draw.shader_program == handle) {
-        cur_state.draw.shader_program = 0;
+OpenGLState& OpenGLState::ResetProgram(GLuint handle) {
+    if (draw.shader_program == handle) {
+        draw.shader_program = 0;
     }
+    return *this;
 }
 
-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;
+OpenGLState& OpenGLState::ResetPipeline(GLuint handle) {
+    if (draw.program_pipeline == handle) {
+        draw.program_pipeline = 0;
     }
+    return *this;
 }
 
-void OpenGLState::ResetVertexArray(GLuint handle) {
-    if (cur_state.draw.vertex_array == handle) {
-        cur_state.draw.vertex_array = 0;
+OpenGLState& OpenGLState::ResetBuffer(GLuint handle) {
+    if (draw.vertex_buffer == handle) {
+        draw.vertex_buffer = 0;
     }
+    if (draw.uniform_buffer == handle) {
+        draw.uniform_buffer = 0;
+    }
+    return *this;
 }
 
-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;
+OpenGLState& OpenGLState::ResetVertexArray(GLuint handle) {
+    if (draw.vertex_array == handle) {
+        draw.vertex_array = 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,27 +122,44 @@ 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 const OpenGLState& GetCurState() {
+    static OpenGLState GetCurState() {
         return cur_state;
     }
 
     /// Apply this state as the current OpenGL state
     void Apply() const;
 
-    /// 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);
+    /// 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);
 
 private:
     static OpenGLState cur_state;

src/video_core/renderer_opengl/gl_stream_buffer.cpp

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

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

@@ -318,7 +318,7 @@ void RendererOpenGL::InitOpenGLObjects() {
                  0.0f);
 
     // Link shaders and get variable locations
-    shader.Create(vertex_shader, fragment_shader);
+    shader.Create(vertex_shader, nullptr, fragment_shader);
     state.draw.shader_program = shader.handle;
     state.Apply();
     uniform_modelview_matrix = glGetUniformLocation(shader.handle, "modelview_matrix");

src/yuzu/main.cpp

@@ -18,7 +18,6 @@
 #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"

src/yuzu_cmd/config.cpp

@@ -91,7 +91,7 @@ void Config::ReadValues() {
 
     // Core
     Settings::values.cpu_core =
-        static_cast<Settings::CpuCore>(sdl2_config->GetInteger("Core", "cpu_core", 0));
+        static_cast<Settings::CpuCore>(sdl2_config->GetInteger("Core", "cpu_core", 1));
 
     // Renderer
     Settings::values.resolution_factor =

src/yuzu_cmd/default_ini.h

@@ -77,7 +77,7 @@ touch_device=
 
 [Core]
 # Which CPU core to use for CPU emulation
-# 0 (default): Unicorn (slow), 1: Dynarmic (faster)
+# 0: Unicorn (slow), 1 (default): Dynarmic (faster)
 cpu_core =
 
 [Renderer]