Address feedback

Minor Readme Changes

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -6,9 +6,9 @@ function(copy_yuzu_Qt5_deps target_dir)
     set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
     set(Qt5_IMAGEFORMATS_DIR "${Qt5_DIR}/../../../plugins/imageformats/")
     set(Qt5_RESOURCES_DIR "${Qt5_DIR}/../../../resources/")
-    set(PLATFORMS ${DLL_DEST}platforms/)
-    set(STYLES ${DLL_DEST}styles/)
-    set(IMAGEFORMATS ${DLL_DEST}imageformats/)
+    set(PLATFORMS ${DLL_DEST}plugins/platforms/)
+    set(STYLES ${DLL_DEST}plugins/styles/)
+    set(IMAGEFORMATS ${DLL_DEST}plugins/imageformats/)
     windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
         icudt*.dll
         icuin*.dll
@@ -42,11 +42,15 @@ function(copy_yuzu_Qt5_deps target_dir)
             icudtl.dat
         )
     endif ()
-
     windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
     windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
     windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS}
         qjpeg$<$<CONFIG:Debug>:d>.*
         qgif$<$<CONFIG:Debug>:d>.*
         )
+    # Create an empty qt.conf file. Qt will detect that this file exists, and use the folder that its in as the root folder.
+    # This way it'll look for plugins in the root/plugins/ folder
+    add_custom_command(TARGET yuzu POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E touch ${DLL_DEST}qt.conf
+    )
 endfunction(copy_yuzu_Qt5_deps)

README.md

@@ -2,6 +2,7 @@ yuzu emulator
 =============
 [![Travis CI Build Status](https://travis-ci.com/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.com/yuzu-emu/yuzu)
 [![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
+[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.gg/XQV6dn9)
 
 yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).
 
@@ -21,7 +22,7 @@ For development discussion, please join us on [Discord](https://discord.gg/XQV6d
 
 Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted.
 
-If you want to contribute please take a look at the [Contributor's Guide](CONTRIBUTING.md) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should also contact any of the developers on Discord in order to know about the current state of the emulator.
+If you want to contribute please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should also contact any of the developers on Discord in order to know about the current state of the emulator.
 
 ### Building
 

externals/microprofile/microprofile.h

@@ -828,7 +828,7 @@ inline MicroProfileLogEntry MicroProfileMakeLogIndex(uint64_t nBegin, MicroProfi
     MicroProfileLogEntry Entry =  (nBegin<<62) | ((0x3fff&nToken)<<48) | (MP_LOG_TICK_MASK&nTick);
     int t = MicroProfileLogType(Entry);
     uint64_t nTimerIndex = MicroProfileLogTimerIndex(Entry);
-    MP_ASSERT(t == nBegin);
+    MP_ASSERT((uint64_t)t == nBegin);
     MP_ASSERT(nTimerIndex == (nToken&0x3fff));
     return Entry;
 
@@ -1556,10 +1556,10 @@ void MicroProfileFlip()
 
         pFramePut->nFrameStartCpu = MP_TICK();
         pFramePut->nFrameStartGpu = (uint32_t)MicroProfileGpuInsertTimeStamp();
-        if(pFrameNext->nFrameStartGpu != (uint64_t)-1)
+        if(pFrameNext->nFrameStartGpu != -1)
             pFrameNext->nFrameStartGpu = MicroProfileGpuGetTimeStamp((uint32_t)pFrameNext->nFrameStartGpu);
 
-        if(pFrameCurrent->nFrameStartGpu == (uint64_t)-1)
+        if(pFrameCurrent->nFrameStartGpu == -1)
             pFrameCurrent->nFrameStartGpu = pFrameNext->nFrameStartGpu + 1;
 
         uint64_t nFrameStartCpu = pFrameCurrent->nFrameStartCpu;

src/core/CMakeLists.txt

@@ -287,6 +287,18 @@ add_library(core STATIC
     hle/service/btm/btm.h
     hle/service/caps/caps.cpp
     hle/service/caps/caps.h
+    hle/service/caps/caps_a.cpp
+    hle/service/caps/caps_a.h
+    hle/service/caps/caps_c.cpp
+    hle/service/caps/caps_c.h
+    hle/service/caps/caps_u.cpp
+    hle/service/caps/caps_u.h
+    hle/service/caps/caps_sc.cpp
+    hle/service/caps/caps_sc.h
+    hle/service/caps/caps_ss.cpp
+    hle/service/caps/caps_ss.h
+    hle/service/caps/caps_su.cpp
+    hle/service/caps/caps_su.h
     hle/service/erpt/erpt.cpp
     hle/service/erpt/erpt.h
     hle/service/es/es.cpp

src/core/core.cpp

@@ -166,7 +166,7 @@ struct System::Impl {
         service_manager = std::make_shared<Service::SM::ServiceManager>();
 
         Service::Init(service_manager, system);
-        GDBStub::Init();
+        GDBStub::DeferStart();
 
         renderer = VideoCore::CreateRenderer(emu_window, system);
         if (!renderer->Init()) {

src/core/gdbstub/gdbstub.cpp

@@ -141,6 +141,7 @@ constexpr char target_xml[] =
 )";
 
 int gdbserver_socket = -1;
+bool defer_start = false;
 
 u8 command_buffer[GDB_BUFFER_SIZE];
 u32 command_length;
@@ -1166,6 +1167,9 @@ static void RemoveBreakpoint() {
 
 void HandlePacket() {
     if (!IsConnected()) {
+        if (defer_start) {
+            ToggleServer(true);
+        }
         return;
     }
 
@@ -1256,6 +1260,10 @@ void ToggleServer(bool status) {
     }
 }
 
+void DeferStart() {
+    defer_start = true;
+}
+
 static void Init(u16 port) {
     if (!server_enabled) {
         // Set the halt loop to false in case the user enabled the gdbstub mid-execution.
@@ -1341,6 +1349,7 @@ void Shutdown() {
     if (!server_enabled) {
         return;
     }
+    defer_start = false;
 
     LOG_INFO(Debug_GDBStub, "Stopping GDB ...");
     if (gdbserver_socket != -1) {

src/core/gdbstub/gdbstub.h

@@ -43,6 +43,13 @@ void ToggleServer(bool status);
 /// Start the gdbstub server.
 void Init();
 
+/**
+ * Defer initialization of the gdbstub to the first packet processing functions.
+ * This avoids a case where the gdbstub thread is frozen after initialization
+ * and fails to respond in time to packets.
+ */
+void DeferStart();
+
 /// Stop gdbstub server.
 void Shutdown();
 

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

@@ -254,6 +254,12 @@ void WebBrowser::Execute() {
 
     if (status != RESULT_SUCCESS) {
         complete = true;
+
+        // This is a workaround in order not to softlock yuzu when an error happens during the
+        // webapplet init. In order to avoid an svcBreak, the status is set to RESULT_SUCCESS
+        Finalize();
+        status = RESULT_SUCCESS;
+
         return;
     }
 

src/core/hle/service/caps/caps.cpp

@@ -2,168 +2,24 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <memory>
-
 #include "core/hle/service/caps/caps.h"
+#include "core/hle/service/caps/caps_a.h"
+#include "core/hle/service/caps/caps_c.h"
+#include "core/hle/service/caps/caps_sc.h"
+#include "core/hle/service/caps/caps_ss.h"
+#include "core/hle/service/caps/caps_su.h"
+#include "core/hle/service/caps/caps_u.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::Capture {
 
-class CAPS_A final : public ServiceFramework<CAPS_A> {
-public:
-    explicit CAPS_A() : ServiceFramework{"caps:a"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetAlbumFileCount"},
-            {1, nullptr, "GetAlbumFileList"},
-            {2, nullptr, "LoadAlbumFile"},
-            {3, nullptr, "DeleteAlbumFile"},
-            {4, nullptr, "StorageCopyAlbumFile"},
-            {5, nullptr, "IsAlbumMounted"},
-            {6, nullptr, "GetAlbumUsage"},
-            {7, nullptr, "GetAlbumFileSize"},
-            {8, nullptr, "LoadAlbumFileThumbnail"},
-            {9, nullptr, "LoadAlbumScreenShotImage"},
-            {10, nullptr, "LoadAlbumScreenShotThumbnailImage"},
-            {11, nullptr, "GetAlbumEntryFromApplicationAlbumEntry"},
-            {12, nullptr, "Unknown12"},
-            {13, nullptr, "Unknown13"},
-            {14, nullptr, "Unknown14"},
-            {15, nullptr, "Unknown15"},
-            {16, nullptr, "Unknown16"},
-            {17, nullptr, "Unknown17"},
-            {18, nullptr, "Unknown18"},
-            {202, nullptr, "SaveEditedScreenShot"},
-            {301, nullptr, "GetLastThumbnail"},
-            {401, nullptr, "GetAutoSavingStorage"},
-            {501, nullptr, "GetRequiredStorageSpaceSizeToCopyAll"},
-            {1001, nullptr, "Unknown1001"},
-            {1002, nullptr, "Unknown1002"},
-            {1003, nullptr, "Unknown1003"},
-            {8001, nullptr, "ForceAlbumUnmounted"},
-            {8002, nullptr, "ResetAlbumMountStatus"},
-            {8011, nullptr, "RefreshAlbumCache"},
-            {8012, nullptr, "GetAlbumCache"},
-            {8013, nullptr, "Unknown8013"},
-            {8021, nullptr, "GetAlbumEntryFromApplicationAlbumEntryAruid"},
-            {10011, nullptr, "SetInternalErrorConversionEnabled"},
-            {50000, nullptr, "Unknown50000"},
-            {60002, nullptr, "Unknown60002"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class CAPS_C final : public ServiceFramework<CAPS_C> {
-public:
-    explicit CAPS_C() : ServiceFramework{"caps:c"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {33, nullptr, "Unknown33"},
-            {2001, nullptr, "Unknown2001"},
-            {2002, nullptr, "Unknown2002"},
-            {2011, nullptr, "Unknown2011"},
-            {2012, nullptr, "Unknown2012"},
-            {2013, nullptr, "Unknown2013"},
-            {2014, nullptr, "Unknown2014"},
-            {2101, nullptr, "Unknown2101"},
-            {2102, nullptr, "Unknown2102"},
-            {2201, nullptr, "Unknown2201"},
-            {2301, nullptr, "Unknown2301"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class CAPS_SC final : public ServiceFramework<CAPS_SC> {
-public:
-    explicit CAPS_SC() : ServiceFramework{"caps:sc"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {1001, nullptr, "Unknown3"},
-            {1002, nullptr, "Unknown4"},
-            {1003, nullptr, "Unknown5"},
-            {1011, nullptr, "Unknown6"},
-            {1012, nullptr, "Unknown7"},
-            {1201, nullptr, "Unknown8"},
-            {1202, nullptr, "Unknown9"},
-            {1203, nullptr, "Unknown10"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class CAPS_SS final : public ServiceFramework<CAPS_SS> {
-public:
-    explicit CAPS_SS() : ServiceFramework{"caps:ss"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {201, nullptr, "Unknown1"},
-            {202, nullptr, "Unknown2"},
-            {203, nullptr, "Unknown3"},
-            {204, nullptr, "Unknown4"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class CAPS_SU final : public ServiceFramework<CAPS_SU> {
-public:
-    explicit CAPS_SU() : ServiceFramework{"caps:su"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {201, nullptr, "SaveScreenShot"},
-            {203, nullptr, "SaveScreenShotEx0"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class CAPS_U final : public ServiceFramework<CAPS_U> {
-public:
-    explicit CAPS_U() : ServiceFramework{"caps:u"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {32, nullptr, "SetShimLibraryVersion"},
-            {102, nullptr, "GetAlbumFileListByAruid"},
-            {103, nullptr, "DeleteAlbumFileByAruid"},
-            {104, nullptr, "GetAlbumFileSizeByAruid"},
-            {105, nullptr, "DeleteAlbumFileByAruidForDebug"},
-            {110, nullptr, "LoadAlbumScreenShotImageByAruid"},
-            {120, nullptr, "LoadAlbumScreenShotThumbnailImageByAruid"},
-            {130, nullptr, "PrecheckToCreateContentsByAruid"},
-            {140, nullptr, "GetAlbumFileList1AafeAruidDeprecated"},
-            {141, nullptr, "GetAlbumFileList2AafeUidAruidDeprecated"},
-            {142, nullptr, "GetAlbumFileList3AaeAruid"},
-            {143, nullptr, "GetAlbumFileList4AaeUidAruid"},
-            {60002, nullptr, "OpenAccessorSessionForApplication"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
 void InstallInterfaces(SM::ServiceManager& sm) {
     std::make_shared<CAPS_A>()->InstallAsService(sm);
     std::make_shared<CAPS_C>()->InstallAsService(sm);
+    std::make_shared<CAPS_U>()->InstallAsService(sm);
     std::make_shared<CAPS_SC>()->InstallAsService(sm);
     std::make_shared<CAPS_SS>()->InstallAsService(sm);
     std::make_shared<CAPS_SU>()->InstallAsService(sm);
-    std::make_shared<CAPS_U>()->InstallAsService(sm);
 }
 
 } // namespace Service::Capture

src/core/hle/service/caps/caps.h

@@ -4,12 +4,83 @@
 
 #pragma once
 
+#include "core/hle/service/service.h"
+
 namespace Service::SM {
 class ServiceManager;
 }
 
 namespace Service::Capture {
 
+enum AlbumImageOrientation {
+    Orientation0 = 0,
+    Orientation1 = 1,
+    Orientation2 = 2,
+    Orientation3 = 3,
+};
+
+enum AlbumReportOption {
+    Disable = 0,
+    Enable = 1,
+};
+
+enum ContentType : u8 {
+    Screenshot = 0,
+    Movie = 1,
+    ExtraMovie = 3,
+};
+
+enum AlbumStorage : u8 {
+    NAND = 0,
+    SD = 1,
+};
+
+struct AlbumFileDateTime {
+    u16 year;
+    u8 month;
+    u8 day;
+    u8 hour;
+    u8 minute;
+    u8 second;
+    u8 uid;
+};
+
+struct AlbumEntry {
+    u64 size;
+    u64 application_id;
+    AlbumFileDateTime datetime;
+    AlbumStorage storage;
+    ContentType content;
+    u8 padding[6];
+};
+
+struct AlbumFileEntry {
+    u64 size;
+    u64 hash;
+    AlbumFileDateTime datetime;
+    AlbumStorage storage;
+    ContentType content;
+    u8 padding[5];
+    u8 unknown;
+};
+
+struct ApplicationAlbumEntry {
+    u64 size;
+    u64 hash;
+    AlbumFileDateTime datetime;
+    AlbumStorage storage;
+    ContentType content;
+    u8 padding[5];
+    u8 unknown;
+};
+
+struct ApplicationAlbumFileEntry {
+    ApplicationAlbumEntry entry;
+    AlbumFileDateTime datetime;
+    u64 unknown;
+};
+
+/// Registers all Capture services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& sm);
 
 } // namespace Service::Capture

src/core/hle/service/caps/caps_a.cpp

@@ -0,0 +1,78 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/caps/caps_a.h"
+
+namespace Service::Capture {
+
+class IAlbumAccessorSession final : public ServiceFramework<IAlbumAccessorSession> {
+public:
+    explicit IAlbumAccessorSession() : ServiceFramework{"IAlbumAccessorSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {2001, nullptr, "OpenAlbumMovieReadStream"},
+            {2002, nullptr, "CloseAlbumMovieReadStream"},
+            {2003, nullptr, "GetAlbumMovieReadStreamMovieDataSize"},
+            {2004, nullptr, "ReadMovieDataFromAlbumMovieReadStream"},
+            {2005, nullptr, "GetAlbumMovieReadStreamBrokenReason"},
+            {2006, nullptr, "GetAlbumMovieReadStreamImageDataSize"},
+            {2007, nullptr, "ReadImageDataFromAlbumMovieReadStream"},
+            {2008, nullptr, "ReadFileAttributeFromAlbumMovieReadStream"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+CAPS_A::CAPS_A() : ServiceFramework("caps:a") {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetAlbumFileCount"},
+        {1, nullptr, "GetAlbumFileList"},
+        {2, nullptr, "LoadAlbumFile"},
+        {3, nullptr, "DeleteAlbumFile"},
+        {4, nullptr, "StorageCopyAlbumFile"},
+        {5, nullptr, "IsAlbumMounted"},
+        {6, nullptr, "GetAlbumUsage"},
+        {7, nullptr, "GetAlbumFileSize"},
+        {8, nullptr, "LoadAlbumFileThumbnail"},
+        {9, nullptr, "LoadAlbumScreenShotImage"},
+        {10, nullptr, "LoadAlbumScreenShotThumbnailImage"},
+        {11, nullptr, "GetAlbumEntryFromApplicationAlbumEntry"},
+        {12, nullptr, "LoadAlbumScreenShotImageEx"},
+        {13, nullptr, "LoadAlbumScreenShotThumbnailImageEx"},
+        {14, nullptr, "LoadAlbumScreenShotImageEx0"},
+        {15, nullptr, "GetAlbumUsage3"},
+        {16, nullptr, "GetAlbumMountResult"},
+        {17, nullptr, "GetAlbumUsage16"},
+        {18, nullptr, "Unknown18"},
+        {100, nullptr, "GetAlbumFileCountEx0"},
+        {101, nullptr, "GetAlbumFileListEx0"},
+        {202, nullptr, "SaveEditedScreenShot"},
+        {301, nullptr, "GetLastThumbnail"},
+        {302, nullptr, "GetLastOverlayMovieThumbnail"},
+        {401, nullptr, "GetAutoSavingStorage"},
+        {501, nullptr, "GetRequiredStorageSpaceSizeToCopyAll"},
+        {1001, nullptr, "LoadAlbumScreenShotThumbnailImageEx0"},
+        {1002, nullptr, "LoadAlbumScreenShotImageEx1"},
+        {1003, nullptr, "LoadAlbumScreenShotThumbnailImageEx1"},
+        {8001, nullptr, "ForceAlbumUnmounted"},
+        {8002, nullptr, "ResetAlbumMountStatus"},
+        {8011, nullptr, "RefreshAlbumCache"},
+        {8012, nullptr, "GetAlbumCache"},
+        {8013, nullptr, "GetAlbumCacheEx"},
+        {8021, nullptr, "GetAlbumEntryFromApplicationAlbumEntryAruid"},
+        {10011, nullptr, "SetInternalErrorConversionEnabled"},
+        {50000, nullptr, "LoadMakerNoteInfoForDebug"},
+        {60002, nullptr, "OpenAccessorSession"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+CAPS_A::~CAPS_A() = default;
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_a.h

@@ -0,0 +1,21 @@
+// Copyright 2020 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 Kernel {
+class HLERequestContext;
+}
+
+namespace Service::Capture {
+
+class CAPS_A final : public ServiceFramework<CAPS_A> {
+public:
+    explicit CAPS_A();
+    ~CAPS_A() override;
+};
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_c.cpp

@@ -0,0 +1,75 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/caps/caps_c.h"
+
+namespace Service::Capture {
+
+class IAlbumControlSession final : public ServiceFramework<IAlbumControlSession> {
+public:
+    explicit IAlbumControlSession() : ServiceFramework{"IAlbumControlSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {2001, nullptr, "OpenAlbumMovieReadStream"},
+            {2002, nullptr, "CloseAlbumMovieReadStream"},
+            {2003, nullptr, "GetAlbumMovieReadStreamMovieDataSize"},
+            {2004, nullptr, "ReadMovieDataFromAlbumMovieReadStream"},
+            {2005, nullptr, "GetAlbumMovieReadStreamBrokenReason"},
+            {2006, nullptr, "GetAlbumMovieReadStreamImageDataSize"},
+            {2007, nullptr, "ReadImageDataFromAlbumMovieReadStream"},
+            {2008, nullptr, "ReadFileAttributeFromAlbumMovieReadStream"},
+            {2401, nullptr, "OpenAlbumMovieWriteStream"},
+            {2402, nullptr, "FinishAlbumMovieWriteStream"},
+            {2403, nullptr, "CommitAlbumMovieWriteStream"},
+            {2404, nullptr, "DiscardAlbumMovieWriteStream"},
+            {2405, nullptr, "DiscardAlbumMovieWriteStreamNoDelete"},
+            {2406, nullptr, "CommitAlbumMovieWriteStreamEx"},
+            {2411, nullptr, "StartAlbumMovieWriteStreamDataSection"},
+            {2412, nullptr, "EndAlbumMovieWriteStreamDataSection"},
+            {2413, nullptr, "StartAlbumMovieWriteStreamMetaSection"},
+            {2414, nullptr, "EndAlbumMovieWriteStreamMetaSection"},
+            {2421, nullptr, "ReadDataFromAlbumMovieWriteStream"},
+            {2422, nullptr, "WriteDataToAlbumMovieWriteStream"},
+            {2424, nullptr, "WriteMetaToAlbumMovieWriteStream"},
+            {2431, nullptr, "GetAlbumMovieWriteStreamBrokenReason"},
+            {2433, nullptr, "GetAlbumMovieWriteStreamDataSize"},
+            {2434, nullptr, "SetAlbumMovieWriteStreamDataSize"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+CAPS_C::CAPS_C() : ServiceFramework("caps:c") {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {1, nullptr, "CaptureRawImage"},
+        {2, nullptr, "CaptureRawImageWithTimeout"},
+        {33, nullptr, "Unknown33"},
+        {1001, nullptr, "RequestTakingScreenShot"},
+        {1002, nullptr, "RequestTakingScreenShotWithTimeout"},
+        {1011, nullptr, "NotifyTakingScreenShotRefused"},
+        {2001, nullptr, "NotifyAlbumStorageIsAvailable"},
+        {2002, nullptr, "NotifyAlbumStorageIsUnavailable"},
+        {2011, nullptr, "RegisterAppletResourceUserId"},
+        {2012, nullptr, "UnregisterAppletResourceUserId"},
+        {2013, nullptr, "GetApplicationIdFromAruid"},
+        {2014, nullptr, "CheckApplicationIdRegistered"},
+        {2101, nullptr, "GenerateCurrentAlbumFileId"},
+        {2102, nullptr, "GenerateApplicationAlbumEntry"},
+        {2201, nullptr, "SaveAlbumScreenShotFile"},
+        {2202, nullptr, "SaveAlbumScreenShotFileEx"},
+        {2301, nullptr, "SetOverlayScreenShotThumbnailData"},
+        {2302, nullptr, "SetOverlayMovieThumbnailData"},
+        {60001, nullptr, "OpenControlSession"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+CAPS_C::~CAPS_C() = default;
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_c.h

@@ -0,0 +1,21 @@
+// Copyright 2020 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 Kernel {
+class HLERequestContext;
+}
+
+namespace Service::Capture {
+
+class CAPS_C final : public ServiceFramework<CAPS_C> {
+public:
+    explicit CAPS_C();
+    ~CAPS_C() override;
+};
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_sc.cpp

@@ -0,0 +1,40 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/caps/caps_sc.h"
+
+namespace Service::Capture {
+
+CAPS_SC::CAPS_SC() : ServiceFramework("caps:sc") {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {1, nullptr, "CaptureRawImage"},
+        {2, nullptr, "CaptureRawImageWithTimeout"},
+        {3, nullptr, "AttachSharedBuffer"},
+        {5, nullptr, "CaptureRawImageToAttachedSharedBuffer"},
+        {210, nullptr, "Unknown210"},
+        {1001, nullptr, "RequestTakingScreenShot"},
+        {1002, nullptr, "RequestTakingScreenShotWithTimeout"},
+        {1003, nullptr, "RequestTakingScreenShotEx"},
+        {1004, nullptr, "RequestTakingScreenShotEx1"},
+        {1009, nullptr, "CancelTakingScreenShot"},
+        {1010, nullptr, "SetTakingScreenShotCancelState"},
+        {1011, nullptr, "NotifyTakingScreenShotRefused"},
+        {1012, nullptr, "NotifyTakingScreenShotFailed"},
+        {1101, nullptr, "SetupOverlayMovieThumbnail"},
+        {1106, nullptr, "Unknown1106"},
+        {1107, nullptr, "Unknown1107"},
+        {1201, nullptr, "OpenRawScreenShotReadStream"},
+        {1202, nullptr, "CloseRawScreenShotReadStream"},
+        {1203, nullptr, "ReadRawScreenShotReadStream"},
+        {1204, nullptr, "Unknown1204"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+CAPS_SC::~CAPS_SC() = default;
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_sc.h

@@ -0,0 +1,21 @@
+// Copyright 2020 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 Kernel {
+class HLERequestContext;
+}
+
+namespace Service::Capture {
+
+class CAPS_SC final : public ServiceFramework<CAPS_SC> {
+public:
+    explicit CAPS_SC();
+    ~CAPS_SC() override;
+};
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_ss.cpp

@@ -0,0 +1,26 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/caps/caps_ss.h"
+
+namespace Service::Capture {
+
+CAPS_SS::CAPS_SS() : ServiceFramework("caps:ss") {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {201, nullptr, "SaveScreenShot"},
+        {202, nullptr, "SaveEditedScreenShot"},
+        {203, nullptr, "SaveScreenShotEx0"},
+        {204, nullptr, "SaveEditedScreenShotEx0"},
+        {206, nullptr, "Unknown206"},
+        {208, nullptr, "SaveScreenShotOfMovieEx1"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+CAPS_SS::~CAPS_SS() = default;
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_ss.h

@@ -0,0 +1,21 @@
+// Copyright 2020 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 Kernel {
+class HLERequestContext;
+}
+
+namespace Service::Capture {
+
+class CAPS_SS final : public ServiceFramework<CAPS_SS> {
+public:
+    explicit CAPS_SS();
+    ~CAPS_SS() override;
+};
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_su.cpp

@@ -0,0 +1,22 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/caps/caps_su.h"
+
+namespace Service::Capture {
+
+CAPS_SU::CAPS_SU() : ServiceFramework("caps:su") {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {201, nullptr, "SaveScreenShot"},
+        {203, nullptr, "SaveScreenShotEx0"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+CAPS_SU::~CAPS_SU() = default;
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_su.h

@@ -0,0 +1,21 @@
+// Copyright 2020 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 Kernel {
+class HLERequestContext;
+}
+
+namespace Service::Capture {
+
+class CAPS_SU final : public ServiceFramework<CAPS_SU> {
+public:
+    explicit CAPS_SU();
+    ~CAPS_SU() override;
+};
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_u.cpp

@@ -0,0 +1,76 @@
+// Copyright 2020 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/caps/caps.h"
+#include "core/hle/service/caps/caps_u.h"
+
+namespace Service::Capture {
+
+class IAlbumAccessorApplicationSession final
+    : public ServiceFramework<IAlbumAccessorApplicationSession> {
+public:
+    explicit IAlbumAccessorApplicationSession()
+        : ServiceFramework{"IAlbumAccessorApplicationSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {2001, nullptr, "OpenAlbumMovieReadStream"},
+            {2002, nullptr, "CloseAlbumMovieReadStream"},
+            {2003, nullptr, "GetAlbumMovieReadStreamMovieDataSize"},
+            {2004, nullptr, "ReadMovieDataFromAlbumMovieReadStream"},
+            {2005, nullptr, "GetAlbumMovieReadStreamBrokenReason"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+CAPS_U::CAPS_U() : ServiceFramework("caps:u") {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {31, nullptr, "GetShimLibraryVersion"},
+        {32, nullptr, "SetShimLibraryVersion"},
+        {102, &CAPS_U::GetAlbumContentsFileListForApplication, "GetAlbumContentsFileListForApplication"},
+        {103, nullptr, "DeleteAlbumContentsFileForApplication"},
+        {104, nullptr, "GetAlbumContentsFileSizeForApplication"},
+        {105, nullptr, "DeleteAlbumFileByAruidForDebug"},
+        {110, nullptr, "LoadAlbumContentsFileScreenShotImageForApplication"},
+        {120, nullptr, "LoadAlbumContentsFileThumbnailImageForApplication"},
+        {130, nullptr, "PrecheckToCreateContentsForApplication"},
+        {140, nullptr, "GetAlbumFileList1AafeAruidDeprecated"},
+        {141, nullptr, "GetAlbumFileList2AafeUidAruidDeprecated"},
+        {142, nullptr, "GetAlbumFileList3AaeAruid"},
+        {143, nullptr, "GetAlbumFileList4AaeUidAruid"},
+        {60002, nullptr, "OpenAccessorSessionForApplication"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+CAPS_U::~CAPS_U() = default;
+
+void CAPS_U::GetAlbumContentsFileListForApplication(Kernel::HLERequestContext& ctx) {
+    // Takes a type-0x6 output buffer containing an array of ApplicationAlbumFileEntry, a PID, an
+    // u8 ContentType, two s64s, and an u64 AppletResourceUserId. Returns an output u64 for total
+    // output entries (which is copied to a s32 by official SW).
+    IPC::RequestParser rp{ctx};
+    [[maybe_unused]] const auto application_album_file_entries = rp.PopRaw<std::array<u8, 0x30>>();
+    const auto pid = rp.Pop<s32>();
+    const auto content_type = rp.PopRaw<ContentType>();
+    [[maybe_unused]] const auto start_datetime = rp.PopRaw<AlbumFileDateTime>();
+    [[maybe_unused]] const auto end_datetime = rp.PopRaw<AlbumFileDateTime>();
+    const auto applet_resource_user_id = rp.Pop<u64>();
+    LOG_WARNING(Service_Capture,
+                "(STUBBED) called. pid={}, content_type={}, applet_resource_user_id={}", pid,
+                content_type, applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<s32>(0);
+}
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_u.h

@@ -0,0 +1,24 @@
+// Copyright 2020 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 Kernel {
+class HLERequestContext;
+}
+
+namespace Service::Capture {
+
+class CAPS_U final : public ServiceFramework<CAPS_U> {
+public:
+    explicit CAPS_U();
+    ~CAPS_U() override;
+
+private:
+    void GetAlbumContentsFileListForApplication(Kernel::HLERequestContext& ctx);
+};
+
+} // namespace Service::Capture

src/core/hle/service/set/set.cpp

@@ -111,6 +111,14 @@ void SET::GetLanguageCode(Kernel::HLERequestContext& ctx) {
     rb.PushEnum(available_language_codes[Settings::values.language_index]);
 }
 
+void SET::GetRegionCode(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(Settings::values.region_index);
+}
+
 SET::SET() : ServiceFramework("set") {
     // clang-format off
     static const FunctionInfo functions[] = {
@@ -118,7 +126,7 @@ SET::SET() : ServiceFramework("set") {
         {1, &SET::GetAvailableLanguageCodes, "GetAvailableLanguageCodes"},
         {2, &SET::MakeLanguageCode, "MakeLanguageCode"},
         {3, &SET::GetAvailableLanguageCodeCount, "GetAvailableLanguageCodeCount"},
-        {4, nullptr, "GetRegionCode"},
+        {4, &SET::GetRegionCode, "GetRegionCode"},
         {5, &SET::GetAvailableLanguageCodes2, "GetAvailableLanguageCodes2"},
         {6, &SET::GetAvailableLanguageCodeCount2, "GetAvailableLanguageCodeCount2"},
         {7, nullptr, "GetKeyCodeMap"},

src/core/hle/service/set/set.h

@@ -43,6 +43,7 @@ private:
     void GetAvailableLanguageCodeCount(Kernel::HLERequestContext& ctx);
     void GetAvailableLanguageCodeCount2(Kernel::HLERequestContext& ctx);
     void GetQuestFlag(Kernel::HLERequestContext& ctx);
+    void GetRegionCode(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Set

src/core/hle/service/sm/controller.cpp

@@ -44,7 +44,7 @@ void Controller::QueryPointerBufferSize(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u16>(0x500);
+    rb.Push<u16>(0x1000);
 }
 
 Controller::Controller() : ServiceFramework("IpcController") {

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

@@ -53,7 +53,7 @@ static std::vector<std::string> BuildLocationNameCache(Core::System& system) {
         return {};
     }
 
-    std::vector<char> raw_data(binary_list->GetSize());
+    std::vector<char> raw_data(binary_list->GetSize() + 1);
     binary_list->ReadBytes<char>(raw_data.data(), binary_list->GetSize());
 
     std::stringstream data_stream{raw_data.data()};

src/core/settings.cpp

@@ -86,6 +86,7 @@ void LogSettings() {
     LogSetting("System_RngSeed", Settings::values.rng_seed.value_or(0));
     LogSetting("System_CurrentUser", Settings::values.current_user);
     LogSetting("System_LanguageIndex", Settings::values.language_index);
+    LogSetting("System_RegionIndex", Settings::values.region_index);
     LogSetting("Core_UseMultiCore", Settings::values.use_multi_core);
     LogSetting("Renderer_UseResolutionFactor", Settings::values.resolution_factor);
     LogSetting("Renderer_UseFrameLimit", Settings::values.use_frame_limit);

src/core/settings.h

@@ -387,6 +387,8 @@ struct Values {
 
     s32 current_user;
     s32 language_index;
+    s32 region_index;
+    s32 sound_index;
 
     // Controls
     std::array<PlayerInput, 10> players;

src/input_common/udp/udp.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <mutex>
+#include <optional>
 #include <tuple>
 
 #include "common/param_package.h"
@@ -44,7 +45,7 @@ public:
     std::unique_ptr<Input::TouchDevice> Create(const Common::ParamPackage& params) override {
         {
             std::lock_guard guard(status->update_mutex);
-            status->touch_calibration.emplace();
+            status->touch_calibration = DeviceStatus::CalibrationData{};
             // These default values work well for DS4 but probably not other touch inputs
             status->touch_calibration->min_x = params.Get("min_x", 100);
             status->touch_calibration->min_y = params.Get("min_y", 50);

src/video_core/dirty_flags.cpp

@@ -15,14 +15,6 @@ namespace VideoCommon::Dirty {
 
 using Tegra::Engines::Maxwell3D;
 
-void SetupCommonOnWriteStores(Tegra::Engines::Maxwell3D::DirtyState::Flags& store) {
-    store[RenderTargets] = true;
-    store[ZetaBuffer] = true;
-    for (std::size_t i = 0; i < Maxwell3D::Regs::NumRenderTargets; ++i) {
-        store[ColorBuffer0 + i] = true;
-    }
-}
-
 void SetupDirtyRenderTargets(Tegra::Engines::Maxwell3D::DirtyState::Tables& tables) {
     static constexpr std::size_t num_per_rt = NUM(rt[0]);
     static constexpr std::size_t begin = OFF(rt);

src/video_core/dirty_flags.h

@@ -44,8 +44,6 @@ void FillBlock(Tegra::Engines::Maxwell3D::DirtyState::Tables& tables, std::size_
     FillBlock(tables[1], begin, num, index_b);
 }
 
-void SetupCommonOnWriteStores(Tegra::Engines::Maxwell3D::DirtyState::Flags& store);
-
 void SetupDirtyRenderTargets(Tegra::Engines::Maxwell3D::DirtyState::Tables& tables);
 
 } // namespace VideoCommon::Dirty

src/video_core/engines/kepler_compute.cpp

@@ -119,14 +119,6 @@ Texture::TICEntry KeplerCompute::GetTICEntry(u32 tic_index) const {
     Texture::TICEntry tic_entry;
     memory_manager.ReadBlockUnsafe(tic_address_gpu, &tic_entry, sizeof(Texture::TICEntry));
 
-    const auto r_type{tic_entry.r_type.Value()};
-    const auto g_type{tic_entry.g_type.Value()};
-    const auto b_type{tic_entry.b_type.Value()};
-    const auto a_type{tic_entry.a_type.Value()};
-
-    // TODO(Subv): Different data types for separate components are not supported
-    DEBUG_ASSERT(r_type == g_type && r_type == b_type && r_type == a_type);
-
     return tic_entry;
 }
 

src/video_core/engines/maxwell_3d.cpp

@@ -98,6 +98,8 @@ void Maxwell3D::InitializeRegisterDefaults() {
     regs.framebuffer_srgb = 1;
     regs.front_face = Maxwell3D::Regs::FrontFace::ClockWise;
 
+    shadow_state = regs;
+
     mme_inline[MAXWELL3D_REG_INDEX(draw.vertex_end_gl)] = true;
     mme_inline[MAXWELL3D_REG_INDEX(draw.vertex_begin_gl)] = true;
     mme_inline[MAXWELL3D_REG_INDEX(vertex_buffer.count)] = true;
@@ -160,8 +162,17 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
     ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid Maxwell3D register, increase the size of the Regs structure");
 
-    if (regs.reg_array[method] != method_call.argument) {
-        regs.reg_array[method] = method_call.argument;
+    u32 arg = method_call.argument;
+    // Keep track of the register value in shadow_state when requested.
+    if (shadow_state.shadow_ram_control == Regs::ShadowRamControl::Track ||
+        shadow_state.shadow_ram_control == Regs::ShadowRamControl::TrackWithFilter) {
+        shadow_state.reg_array[method] = arg;
+    } else if (shadow_state.shadow_ram_control == Regs::ShadowRamControl::Replay) {
+        arg = shadow_state.reg_array[method];
+    }
+
+    if (regs.reg_array[method] != arg) {
+        regs.reg_array[method] = arg;
 
         for (const auto& table : dirty.tables) {
             dirty.flags[table[method]] = true;
@@ -169,12 +180,16 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
     }
 
     switch (method) {
+    case MAXWELL3D_REG_INDEX(shadow_ram_control): {
+        shadow_state.shadow_ram_control = static_cast<Regs::ShadowRamControl>(method_call.argument);
+        break;
+    }
     case MAXWELL3D_REG_INDEX(macros.data): {
-        ProcessMacroUpload(method_call.argument);
+        ProcessMacroUpload(arg);
         break;
     }
     case MAXWELL3D_REG_INDEX(macros.bind): {
-        ProcessMacroBind(method_call.argument);
+        ProcessMacroBind(arg);
         break;
     }
     case MAXWELL3D_REG_INDEX(firmware[4]): {
@@ -250,7 +265,7 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
     }
     case MAXWELL3D_REG_INDEX(data_upload): {
         const bool is_last_call = method_call.IsLastCall();
-        upload_state.ProcessData(method_call.argument, is_last_call);
+        upload_state.ProcessData(arg, is_last_call);
         if (is_last_call) {
             OnMemoryWrite();
         }

src/video_core/engines/maxwell_3d.h

@@ -531,6 +531,17 @@ public:
             Fill = 0x1b02,
         };
 
+        enum class ShadowRamControl : u32 {
+            // write value to shadow ram
+            Track = 0,
+            // write value to shadow ram ( with validation ??? )
+            TrackWithFilter = 1,
+            // only write to real hw register
+            Passthrough = 2,
+            // write value from shadow ram to real hw register
+            Replay = 3,
+        };
+
         struct RenderTargetConfig {
             u32 address_high;
             u32 address_low;
@@ -674,7 +685,9 @@ public:
                     u32 bind;
                 } macros;
 
-                INSERT_UNION_PADDING_WORDS(0x17);
+                ShadowRamControl shadow_ram_control;
+
+                INSERT_UNION_PADDING_WORDS(0x16);
 
                 Upload::Registers upload;
                 struct {
@@ -1263,7 +1276,12 @@ public:
             };
             std::array<u32, NUM_REGS> reg_array;
         };
-    } regs{};
+    };
+
+    Regs regs{};
+
+    /// Store temporary hw register values, used by some calls to restore state after a operation
+    Regs shadow_state;
 
     static_assert(sizeof(Regs) == Regs::NUM_REGS * sizeof(u32), "Maxwell3D Regs has wrong size");
     static_assert(std::is_trivially_copyable_v<Regs>, "Maxwell3D Regs must be trivially copyable");
@@ -1458,6 +1476,7 @@ private:
                   "Field " #field_name " has invalid position")
 
 ASSERT_REG_POSITION(macros, 0x45);
+ASSERT_REG_POSITION(shadow_ram_control, 0x49);
 ASSERT_REG_POSITION(upload, 0x60);
 ASSERT_REG_POSITION(exec_upload, 0x6C);
 ASSERT_REG_POSITION(data_upload, 0x6D);

src/video_core/engines/shader_bytecode.h

@@ -82,6 +82,10 @@ union Attribute {
         Position = 7,
         Attribute_0 = 8,
         Attribute_31 = 39,
+        FrontColor = 40,
+        FrontSecondaryColor = 41,
+        BackColor = 42,
+        BackSecondaryColor = 43,
         ClipDistances0123 = 44,
         ClipDistances4567 = 45,
         PointCoord = 46,
@@ -89,6 +93,8 @@ union Attribute {
         // shader, and a tuple of (TessCoord.x, TessCoord.y, TessCoord.z, ~) when inside a Tess Eval
         // shader.
         TessCoordInstanceIDVertexID = 47,
+        TexCoord_0 = 48,
+        TexCoord_7 = 55,
         // This attribute contains a tuple of (Unk, Unk, Unk, gl_FrontFacing) when inside a fragment
         // shader. It is unknown what the other values contain.
         FrontFacing = 63,

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -93,10 +93,6 @@ void oglEnable(GLenum cap, bool state) {
     (state ? glEnable : glDisable)(cap);
 }
 
-void oglEnablei(GLenum cap, bool state, GLuint index) {
-    (state ? glEnablei : glDisablei)(cap, index);
-}
-
 } // Anonymous namespace
 
 RasterizerOpenGL::RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWindow& emu_window,
@@ -478,7 +474,6 @@ void RasterizerOpenGL::Clear() {
 void RasterizerOpenGL::Draw(bool is_indexed, bool is_instanced) {
     MICROPROFILE_SCOPE(OpenGL_Drawing);
     auto& gpu = system.GPU().Maxwell3D();
-    const auto& regs = gpu.regs;
 
     query_cache.UpdateCounters();
 
@@ -529,7 +524,7 @@ void RasterizerOpenGL::Draw(bool is_indexed, bool is_instanced) {
     // Upload vertex and index data.
     SetupVertexBuffer();
     SetupVertexInstances();
-    GLintptr index_buffer_offset;
+    GLintptr index_buffer_offset = 0;
     if (is_indexed) {
         index_buffer_offset = SetupIndexBuffer();
     }
@@ -555,7 +550,7 @@ void RasterizerOpenGL::Draw(bool is_indexed, bool is_instanced) {
     ConfigureFramebuffers();
 
     // Signal the buffer cache that we are not going to upload more things.
-    const bool invalidate = buffer_cache.Unmap();
+    buffer_cache.Unmap();
 
     // Now that we are no longer uploading data, we can safely bind the buffers to OpenGL.
     vertex_array_pushbuffer.Bind();
@@ -938,13 +933,15 @@ void RasterizerOpenGL::SyncViewport() {
             }
             flags[Dirty::Viewport0 + i] = false;
 
-            const Common::Rectangle<f32> rect{regs.viewport_transform[i].GetRect()};
+            const auto& src = regs.viewport_transform[i];
+            const Common::Rectangle<f32> rect{src.GetRect()};
             glViewportIndexedf(static_cast<GLuint>(i), rect.left, rect.bottom, rect.GetWidth(),
                                rect.GetHeight());
 
-            const auto& src = regs.viewports[i];
-            glDepthRangeIndexed(static_cast<GLuint>(i), static_cast<GLdouble>(src.depth_range_near),
-                                static_cast<GLdouble>(src.depth_range_far));
+            const GLdouble reduce_z = regs.depth_mode == Maxwell::DepthMode::MinusOneToOne;
+            const GLdouble near_depth = src.translate_z - src.scale_z * reduce_z;
+            const GLdouble far_depth = src.translate_z + src.scale_z;
+            glDepthRangeIndexed(static_cast<GLuint>(i), near_depth, far_depth);
         }
     }
 }

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -366,10 +366,19 @@ constexpr bool IsGenericAttribute(Attribute::Index index) {
     return index >= Attribute::Index::Attribute_0 && index <= Attribute::Index::Attribute_31;
 }
 
+constexpr bool IsLegacyTexCoord(Attribute::Index index) {
+    return static_cast<int>(index) >= static_cast<int>(Attribute::Index::TexCoord_0) &&
+           static_cast<int>(index) <= static_cast<int>(Attribute::Index::TexCoord_7);
+}
+
 constexpr Attribute::Index ToGenericAttribute(u64 value) {
     return static_cast<Attribute::Index>(value + static_cast<u64>(Attribute::Index::Attribute_0));
 }
 
+constexpr int GetLegacyTexCoordIndex(Attribute::Index index) {
+    return static_cast<int>(index) - static_cast<int>(Attribute::Index::TexCoord_0);
+}
+
 u32 GetGenericAttributeIndex(Attribute::Index index) {
     ASSERT(IsGenericAttribute(index));
     return static_cast<u32>(index) - static_cast<u32>(Attribute::Index::Attribute_0);
@@ -393,10 +402,6 @@ std::string FlowStackTopName(MetaStackClass stack) {
     return fmt::format("{}_flow_stack_top", GetFlowStackPrefix(stack));
 }
 
-[[deprecated]] constexpr bool IsVertexShader(ShaderType stage) {
-    return stage == ShaderType::Vertex;
-}
-
 struct GenericVaryingDescription {
     std::string name;
     u8 first_element = 0;
@@ -502,7 +507,7 @@ private:
         if (!identifier.empty()) {
             code.AddLine("// {}", identifier);
         }
-        code.AddLine("#version 440 core");
+        code.AddLine("#version 440 {}", ir.UsesLegacyVaryings() ? "compatibility" : "core");
         code.AddLine("#extension GL_ARB_separate_shader_objects : enable");
         if (device.HasShaderBallot()) {
             code.AddLine("#extension GL_ARB_shader_ballot : require");
@@ -529,8 +534,9 @@ private:
     }
 
     void DeclareVertex() {
-        if (!IsVertexShader(stage))
+        if (stage != ShaderType::Vertex) {
             return;
+        }
 
         DeclareVertexRedeclarations();
     }
@@ -564,6 +570,16 @@ private:
         if (stage != ShaderType::Fragment) {
             return;
         }
+        if (ir.UsesLegacyVaryings()) {
+            code.AddLine("in gl_PerFragment {{");
+            ++code.scope;
+            code.AddLine("vec4 gl_TexCoord[8];");
+            code.AddLine("vec4 gl_Color;");
+            code.AddLine("vec4 gl_SecondaryColor;");
+            --code.scope;
+            code.AddLine("}};");
+        }
+
         for (u32 rt = 0; rt < Maxwell::NumRenderTargets; ++rt) {
             code.AddLine("layout (location = {}) out vec4 frag_color{};", rt, rt);
         }
@@ -602,14 +618,14 @@ private:
                 break;
             }
         }
-        if (!IsVertexShader(stage) || device.HasVertexViewportLayer()) {
+        if (stage != ShaderType::Vertex || device.HasVertexViewportLayer()) {
             if (ir.UsesLayer()) {
                 code.AddLine("int gl_Layer;");
             }
             if (ir.UsesViewportIndex()) {
                 code.AddLine("int gl_ViewportIndex;");
             }
-        } else if ((ir.UsesLayer() || ir.UsesViewportIndex()) && IsVertexShader(stage) &&
+        } else if ((ir.UsesLayer() || ir.UsesViewportIndex()) && stage == ShaderType::Vertex &&
                    !device.HasVertexViewportLayer()) {
             LOG_ERROR(
                 Render_OpenGL,
@@ -620,12 +636,12 @@ private:
             code.AddLine("float gl_PointSize;");
         }
 
-        if (ir.UsesInstanceId()) {
-            code.AddLine("int gl_InstanceID;");
-        }
-
-        if (ir.UsesVertexId()) {
-            code.AddLine("int gl_VertexID;");
+        if (ir.UsesLegacyVaryings()) {
+            code.AddLine("vec4 gl_TexCoord[8];");
+            code.AddLine("vec4 gl_FrontColor;");
+            code.AddLine("vec4 gl_FrontSecondaryColor;");
+            code.AddLine("vec4 gl_BackColor;");
+            code.AddLine("vec4 gl_BackSecondaryColor;");
         }
 
         --code.scope;
@@ -1131,6 +1147,10 @@ private:
             default:
                 UNREACHABLE();
             }
+        case Attribute::Index::FrontColor:
+            return {"gl_Color"s + GetSwizzle(element), Type::Float};
+        case Attribute::Index::FrontSecondaryColor:
+            return {"gl_SecondaryColor"s + GetSwizzle(element), Type::Float};
         case Attribute::Index::PointCoord:
             switch (element) {
             case 0:
@@ -1147,7 +1167,7 @@ private:
             // TODO(Subv): Find out what the values are for the first two elements when inside a
             // vertex shader, and what's the value of the fourth element when inside a Tess Eval
             // shader.
-            ASSERT(IsVertexShader(stage));
+            ASSERT(stage == ShaderType::Vertex);
             switch (element) {
             case 2:
                 // Config pack's first value is instance_id.
@@ -1171,6 +1191,12 @@ private:
                 return {GeometryPass(GetGenericInputAttribute(attribute)) + GetSwizzle(element),
                         Type::Float};
             }
+            if (IsLegacyTexCoord(attribute)) {
+                UNIMPLEMENTED_IF(stage == ShaderType::Geometry);
+                return {fmt::format("gl_TexCoord[{}]{}", GetLegacyTexCoordIndex(attribute),
+                                    GetSwizzle(element)),
+                        Type::Float};
+            }
             break;
         }
         UNIMPLEMENTED_MSG("Unhandled input attribute: {}", static_cast<u32>(attribute));
@@ -1209,21 +1235,22 @@ private:
     }
 
     std::optional<Expression> GetOutputAttribute(const AbufNode* abuf) {
+        const u32 element = abuf->GetElement();
         switch (const auto attribute = abuf->GetIndex()) {
         case Attribute::Index::Position:
-            return {{"gl_Position"s + GetSwizzle(abuf->GetElement()), Type::Float}};
+            return {{"gl_Position"s + GetSwizzle(element), Type::Float}};
         case Attribute::Index::LayerViewportPointSize:
-            switch (abuf->GetElement()) {
+            switch (element) {
             case 0:
                 UNIMPLEMENTED();
                 return {};
             case 1:
-                if (IsVertexShader(stage) && !device.HasVertexViewportLayer()) {
+                if (stage == ShaderType::Vertex && !device.HasVertexViewportLayer()) {
                     return {};
                 }
                 return {{"gl_Layer", Type::Int}};
             case 2:
-                if (IsVertexShader(stage) && !device.HasVertexViewportLayer()) {
+                if (stage == ShaderType::Vertex && !device.HasVertexViewportLayer()) {
                     return {};
                 }
                 return {{"gl_ViewportIndex", Type::Int}};
@@ -1231,13 +1258,26 @@ private:
                 return {{"gl_PointSize", Type::Float}};
             }
             return {};
+        case Attribute::Index::FrontColor:
+            return {{"gl_FrontColor"s + GetSwizzle(element), Type::Float}};
+        case Attribute::Index::FrontSecondaryColor:
+            return {{"gl_FrontSecondaryColor"s + GetSwizzle(element), Type::Float}};
+        case Attribute::Index::BackColor:
+            return {{"gl_BackColor"s + GetSwizzle(element), Type::Float}};
+        case Attribute::Index::BackSecondaryColor:
+            return {{"gl_BackSecondaryColor"s + GetSwizzle(element), Type::Float}};
         case Attribute::Index::ClipDistances0123:
-            return {{fmt::format("gl_ClipDistance[{}]", abuf->GetElement()), Type::Float}};
+            return {{fmt::format("gl_ClipDistance[{}]", element), Type::Float}};
         case Attribute::Index::ClipDistances4567:
-            return {{fmt::format("gl_ClipDistance[{}]", abuf->GetElement() + 4), Type::Float}};
+            return {{fmt::format("gl_ClipDistance[{}]", element + 4), Type::Float}};
         default:
             if (IsGenericAttribute(attribute)) {
-                return {{GetGenericOutputAttribute(attribute, abuf->GetElement()), Type::Float}};
+                return {{GetGenericOutputAttribute(attribute, element), Type::Float}};
+            }
+            if (IsLegacyTexCoord(attribute)) {
+                return {{fmt::format("gl_TexCoord[{}]{}", GetLegacyTexCoordIndex(attribute),
+                                     GetSwizzle(element)),
+                         Type::Float}};
             }
             UNIMPLEMENTED_MSG("Unhandled output attribute: {}", static_cast<u32>(attribute));
             return {};
@@ -2009,16 +2049,19 @@ private:
         expr += GetSampler(meta->sampler);
         expr += ", ";
 
-        expr += constructors.at(operation.GetOperandsCount() - 1);
+        expr += constructors.at(operation.GetOperandsCount() + (meta->array ? 1 : 0) - 1);
         expr += '(';
         for (std::size_t i = 0; i < count; ++i) {
-            expr += VisitOperand(operation, i).AsInt();
-            const std::size_t next = i + 1;
-            if (next == count)
-                expr += ')';
-            else if (next < count)
+            if (i > 0) {
                 expr += ", ";
+            }
+            expr += VisitOperand(operation, i).AsInt();
         }
+        if (meta->array) {
+            expr += ", ";
+            expr += Visit(meta->array).AsInt();
+        }
+        expr += ')';
 
         if (meta->lod && !meta->sampler.IsBuffer()) {
             expr += ", ";
@@ -2529,7 +2572,7 @@ private:
     }
 
     u32 GetNumPhysicalInputAttributes() const {
-        return IsVertexShader(stage) ? GetNumPhysicalAttributes() : GetNumPhysicalVaryings();
+        return stage == ShaderType::Vertex ? GetNumPhysicalAttributes() : GetNumPhysicalVaryings();
     }
 
     u32 GetNumPhysicalAttributes() const {

src/video_core/renderer_opengl/gl_state_tracker.cpp

@@ -238,7 +238,6 @@ void StateTracker::Initialize() {
     SetupDirtyMisc(tables);
 
     auto& store = dirty.on_write_stores;
-    SetupCommonOnWriteStores(store);
     store[VertexBuffers] = true;
     for (std::size_t i = 0; i < Regs::NumVertexArrays; ++i) {
         store[VertexBuffer0 + i] = true;

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -257,6 +257,8 @@ vk::ShaderStageFlagBits ShaderStage(Tegra::Engines::ShaderType stage) {
         return vk::ShaderStageFlagBits::eGeometry;
     case Tegra::Engines::ShaderType::Fragment:
         return vk::ShaderStageFlagBits::eFragment;
+    case Tegra::Engines::ShaderType::Compute:
+        return vk::ShaderStageFlagBits::eCompute;
     }
     UNIMPLEMENTED_MSG("Unimplemented shader stage={}", static_cast<u32>(stage));
     return {};
@@ -367,6 +369,10 @@ vk::Format VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttr
             return vk::Format::eR8G8B8A8Uint;
         case Maxwell::VertexAttribute::Size::Size_32:
             return vk::Format::eR32Uint;
+        case Maxwell::VertexAttribute::Size::Size_32_32:
+            return vk::Format::eR32G32Uint;
+        case Maxwell::VertexAttribute::Size::Size_32_32_32:
+            return vk::Format::eR32G32B32Uint;
         case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
             return vk::Format::eR32G32B32A32Uint;
         default:

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -179,10 +179,11 @@ Tegra::Engines::ConstBufferEngineInterface& CachedShader::GetEngine(
 VKPipelineCache::VKPipelineCache(Core::System& system, RasterizerVulkan& rasterizer,
                                  const VKDevice& device, VKScheduler& scheduler,
                                  VKDescriptorPool& descriptor_pool,
-                                 VKUpdateDescriptorQueue& update_descriptor_queue)
+                                 VKUpdateDescriptorQueue& update_descriptor_queue,
+                                 VKRenderPassCache& renderpass_cache)
     : RasterizerCache{rasterizer}, system{system}, device{device}, scheduler{scheduler},
       descriptor_pool{descriptor_pool}, update_descriptor_queue{update_descriptor_queue},
-      renderpass_cache(device) {}
+      renderpass_cache{renderpass_cache} {}
 
 VKPipelineCache::~VKPipelineCache() = default;
 
@@ -191,7 +192,6 @@ std::array<Shader, Maxwell::MaxShaderProgram> VKPipelineCache::GetShaders() {
 
     std::array<Shader, Maxwell::MaxShaderProgram> shaders;
     for (std::size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
-        const auto& shader_config = gpu.regs.shader_config[index];
         const auto program{static_cast<Maxwell::ShaderProgram>(index)};
 
         // Skip stages that are not enabled

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -161,7 +161,8 @@ public:
     explicit VKPipelineCache(Core::System& system, RasterizerVulkan& rasterizer,
                              const VKDevice& device, VKScheduler& scheduler,
                              VKDescriptorPool& descriptor_pool,
-                             VKUpdateDescriptorQueue& update_descriptor_queue);
+                             VKUpdateDescriptorQueue& update_descriptor_queue,
+                             VKRenderPassCache& renderpass_cache);
     ~VKPipelineCache();
 
     std::array<Shader, Maxwell::MaxShaderProgram> GetShaders();
@@ -184,8 +185,7 @@ private:
     VKScheduler& scheduler;
     VKDescriptorPool& descriptor_pool;
     VKUpdateDescriptorQueue& update_descriptor_queue;
-
-    VKRenderPassCache renderpass_cache;
+    VKRenderPassCache& renderpass_cache;
 
     std::array<Shader, Maxwell::MaxShaderProgram> last_shaders;
 

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -287,12 +287,13 @@ RasterizerVulkan::RasterizerVulkan(Core::System& system, Core::Frontend::EmuWind
       screen_info{screen_info}, device{device}, resource_manager{resource_manager},
       memory_manager{memory_manager}, state_tracker{state_tracker}, scheduler{scheduler},
       staging_pool(device, memory_manager, scheduler), descriptor_pool(device),
-      update_descriptor_queue(device, scheduler),
+      update_descriptor_queue(device, scheduler), renderpass_cache(device),
       quad_array_pass(device, scheduler, descriptor_pool, staging_pool, update_descriptor_queue),
       uint8_pass(device, scheduler, descriptor_pool, staging_pool, update_descriptor_queue),
       texture_cache(system, *this, device, resource_manager, memory_manager, scheduler,
                     staging_pool),
-      pipeline_cache(system, *this, device, scheduler, descriptor_pool, update_descriptor_queue),
+      pipeline_cache(system, *this, device, scheduler, descriptor_pool, update_descriptor_queue,
+                     renderpass_cache),
       buffer_cache(*this, system, device, memory_manager, scheduler, staging_pool),
       sampler_cache(device), query_cache(system, *this, device, scheduler) {
     scheduler.SetQueryCache(query_cache);
@@ -365,13 +366,16 @@ void RasterizerVulkan::Draw(bool is_indexed, bool is_instanced) {
 void RasterizerVulkan::Clear() {
     MICROPROFILE_SCOPE(Vulkan_Clearing);
 
-    query_cache.UpdateCounters();
-
     const auto& gpu = system.GPU().Maxwell3D();
     if (!system.GPU().Maxwell3D().ShouldExecute()) {
         return;
     }
 
+    sampled_views.clear();
+    image_views.clear();
+
+    query_cache.UpdateCounters();
+
     const auto& regs = gpu.regs;
     const bool use_color = regs.clear_buffers.R || regs.clear_buffers.G || regs.clear_buffers.B ||
                            regs.clear_buffers.A;
@@ -380,52 +384,54 @@ void RasterizerVulkan::Clear() {
     if (!use_color && !use_depth && !use_stencil) {
         return;
     }
-    // Clearing images requires to be out of a renderpass
-    scheduler.RequestOutsideRenderPassOperationContext();
 
-    // TODO(Rodrigo): Implement clears rendering a quad or using beginning a renderpass.
+    [[maybe_unused]] const auto texceptions = UpdateAttachments();
+    DEBUG_ASSERT(texceptions.none());
+    SetupImageTransitions(0, color_attachments, zeta_attachment);
+
+    const vk::RenderPass renderpass = renderpass_cache.GetRenderPass(GetRenderPassParams(0));
+    const auto [framebuffer, render_area] = ConfigureFramebuffers(renderpass);
+    scheduler.RequestRenderpass({renderpass, framebuffer, {{0, 0}, render_area}, 0, nullptr});
+
+    const auto& scissor = regs.scissor_test[0];
+    const vk::Offset2D scissor_offset(scissor.min_x, scissor.min_y);
+    vk::Extent2D scissor_extent{scissor.max_x - scissor.min_x, scissor.max_y - scissor.min_y};
+    scissor_extent.width = std::min(scissor_extent.width, render_area.width);
+    scissor_extent.height = std::min(scissor_extent.height, render_area.height);
+
+    const u32 layer = regs.clear_buffers.layer;
+    const vk::ClearRect clear_rect({scissor_offset, scissor_extent}, layer, 1);
 
     if (use_color) {
-        View color_view;
-        {
-            MICROPROFILE_SCOPE(Vulkan_RenderTargets);
-            color_view = texture_cache.GetColorBufferSurface(regs.clear_buffers.RT.Value(), false);
-        }
-
-        color_view->Transition(vk::ImageLayout::eTransferDstOptimal,
-                               vk::PipelineStageFlagBits::eTransfer,
-                               vk::AccessFlagBits::eTransferWrite);
-
         const std::array clear_color = {regs.clear_color[0], regs.clear_color[1],
                                         regs.clear_color[2], regs.clear_color[3]};
-        const vk::ClearColorValue clear(clear_color);
-        scheduler.Record([image = color_view->GetImage(),
-                          subresource = color_view->GetImageSubresourceRange(),
-                          clear](auto cmdbuf, auto& dld) {
-            cmdbuf.clearColorImage(image, vk::ImageLayout::eTransferDstOptimal, clear, subresource,
-                                   dld);
+        const vk::ClearValue clear_value{clear_color};
+        const u32 color_attachment = regs.clear_buffers.RT;
+        scheduler.Record([color_attachment, clear_value, clear_rect](auto cmdbuf, auto& dld) {
+            const vk::ClearAttachment attachment(vk::ImageAspectFlagBits::eColor, color_attachment,
+                                                 clear_value);
+            cmdbuf.clearAttachments(1, &attachment, 1, &clear_rect, dld);
         });
     }
-    if (use_depth || use_stencil) {
-        View zeta_surface;
-        {
-            MICROPROFILE_SCOPE(Vulkan_RenderTargets);
-            zeta_surface = texture_cache.GetDepthBufferSurface(false);
-        }
 
-        zeta_surface->Transition(vk::ImageLayout::eTransferDstOptimal,
-                                 vk::PipelineStageFlagBits::eTransfer,
-                                 vk::AccessFlagBits::eTransferWrite);
-
-        const vk::ClearDepthStencilValue clear(regs.clear_depth,
-                                               static_cast<u32>(regs.clear_stencil));
-        scheduler.Record([image = zeta_surface->GetImage(),
-                          subresource = zeta_surface->GetImageSubresourceRange(),
-                          clear](auto cmdbuf, auto& dld) {
-            cmdbuf.clearDepthStencilImage(image, vk::ImageLayout::eTransferDstOptimal, clear,
-                                          subresource, dld);
-        });
+    if (!use_depth && !use_stencil) {
+        return;
     }
+    vk::ImageAspectFlags aspect_flags;
+    if (use_depth) {
+        aspect_flags |= vk::ImageAspectFlagBits::eDepth;
+    }
+    if (use_stencil) {
+        aspect_flags |= vk::ImageAspectFlagBits::eStencil;
+    }
+
+    scheduler.Record([clear_depth = regs.clear_depth, clear_stencil = regs.clear_stencil,
+                      clear_rect, aspect_flags](auto cmdbuf, auto& dld) {
+        const vk::ClearDepthStencilValue clear_zeta(clear_depth, clear_stencil);
+        const vk::ClearValue clear_value{clear_zeta};
+        const vk::ClearAttachment attachment(aspect_flags, 0, clear_value);
+        cmdbuf.clearAttachments(1, &attachment, 1, &clear_rect, dld);
+    });
 }
 
 void RasterizerVulkan::DispatchCompute(GPUVAddr code_addr) {
@@ -542,8 +548,6 @@ bool RasterizerVulkan::AccelerateDisplay(const Tegra::FramebufferConfig& config,
 
     // Verify that the cached surface is the same size and format as the requested framebuffer
     const auto& params{surface->GetSurfaceParams()};
-    const auto& pixel_format{
-        VideoCore::Surface::PixelFormatFromGPUPixelFormat(config.pixel_format)};
     ASSERT_MSG(params.width == config.width, "Framebuffer width is different");
     ASSERT_MSG(params.height == config.height, "Framebuffer height is different");
 

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -253,6 +253,7 @@ private:
     VKStagingBufferPool staging_pool;
     VKDescriptorPool descriptor_pool;
     VKUpdateDescriptorQueue update_descriptor_queue;
+    VKRenderPassCache renderpass_cache;
     QuadArrayPass quad_array_pass;
     Uint8Pass uint8_pass;
 

src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp

@@ -100,7 +100,6 @@ void VKStagingBufferPool::ReleaseCache(bool host_visible) {
 }
 
 u64 VKStagingBufferPool::ReleaseLevel(StagingBuffersCache& cache, std::size_t log2) {
-    static constexpr u64 epochs_to_destroy = 180;
     static constexpr std::size_t deletions_per_tick = 16;
 
     auto& staging = cache[log2];
@@ -108,6 +107,7 @@ u64 VKStagingBufferPool::ReleaseLevel(StagingBuffersCache& cache, std::size_t lo
     const std::size_t old_size = entries.size();
 
     const auto is_deleteable = [this](const auto& entry) {
+        static constexpr u64 epochs_to_destroy = 180;
         return entry.last_epoch + epochs_to_destroy < epoch && !entry.watch.IsUsed();
     };
     const std::size_t begin_offset = staging.delete_index;

src/video_core/renderer_vulkan/vk_state_tracker.cpp

@@ -90,8 +90,6 @@ void StateTracker::Initialize() {
     SetupDirtyBlendConstants(tables);
     SetupDirtyDepthBounds(tables);
     SetupDirtyStencilProperties(tables);
-
-    SetupCommonOnWriteStores(dirty.on_write_stores);
 }
 
 void StateTracker::InvalidateCommandBufferState() {

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -52,6 +52,9 @@ vk::ImageType SurfaceTargetToImage(SurfaceTarget target) {
         return vk::ImageType::e2D;
     case SurfaceTarget::Texture3D:
         return vk::ImageType::e3D;
+    case SurfaceTarget::TextureBuffer:
+        UNREACHABLE();
+        return {};
     }
     UNREACHABLE_MSG("Unknown texture target={}", static_cast<u32>(target));
     return {};
@@ -273,7 +276,6 @@ void CachedSurface::UploadImage(const std::vector<u8>& staging_buffer) {
 
     for (u32 level = 0; level < params.num_levels; ++level) {
         vk::BufferImageCopy copy = GetBufferImageCopy(level);
-        const auto& dld = device.GetDispatchLoader();
         if (image->GetAspectMask() ==
             (vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil)) {
             vk::BufferImageCopy depth = copy;
@@ -422,7 +424,6 @@ void VKTextureCache::ImageCopy(Surface& src_surface, Surface& dst_surface,
         dst_base_layer, num_layers, copy_params.dest_level, 1, vk::PipelineStageFlagBits::eTransfer,
         vk::AccessFlagBits::eTransferWrite, vk::ImageLayout::eTransferDstOptimal);
 
-    const auto& dld{device.GetDispatchLoader()};
     const vk::ImageSubresourceLayers src_subresource(
         src_surface->GetAspectMask(), copy_params.source_level, copy_params.source_z, num_layers);
     const vk::ImageSubresourceLayers dst_subresource(
@@ -458,7 +459,6 @@ void VKTextureCache::ImageBlit(View& src_view, View& dst_view,
                              dst_view->GetImageSubresourceLayers(), {dst_top_left, dst_bot_right});
     const bool is_linear = copy_config.filter == Tegra::Engines::Fermi2D::Filter::Linear;
 
-    const auto& dld{device.GetDispatchLoader()};
     scheduler.Record([src_image = src_view->GetImage(), dst_image = dst_view->GetImage(), blit,
                       is_linear](auto cmdbuf, auto& dld) {
         cmdbuf.blitImage(src_image, vk::ImageLayout::eTransferSrcOptimal, dst_image,

src/video_core/shader/decode/xmad.cpp

@@ -12,6 +12,7 @@ namespace VideoCommon::Shader {
 
 using Tegra::Shader::Instruction;
 using Tegra::Shader::OpCode;
+using Tegra::Shader::PredCondition;
 
 u32 ShaderIR::DecodeXmad(NodeBlock& bb, u32 pc) {
     const Instruction instr = {program_code[pc]};
@@ -30,7 +31,7 @@ u32 ShaderIR::DecodeXmad(NodeBlock& bb, u32 pc) {
     const bool is_signed_b = instr.xmad.sign_b == 1;
     const bool is_signed_c = is_signed_a;
 
-    auto [is_merge, is_psl, is_high_b, mode, op_b,
+    auto [is_merge, is_psl, is_high_b, mode, op_b_binding,
           op_c] = [&]() -> std::tuple<bool, bool, bool, Tegra::Shader::XmadMode, Node, Node> {
         switch (opcode->get().GetId()) {
         case OpCode::Id::XMAD_CR:
@@ -63,15 +64,19 @@ u32 ShaderIR::DecodeXmad(NodeBlock& bb, u32 pc) {
         }
     }();
 
-    op_a = BitfieldExtract(op_a, instr.xmad.high_a ? 16 : 0, 16);
+    op_a = SignedOperation(OperationCode::IBitfieldExtract, is_signed_a, std::move(op_a),
+                           instr.xmad.high_a ? Immediate(16) : Immediate(0), Immediate(16));
 
-    const Node original_b = op_b;
-    op_b = BitfieldExtract(op_b, is_high_b ? 16 : 0, 16);
+    const Node original_b = op_b_binding;
+    const Node op_b =
+        SignedOperation(OperationCode::IBitfieldExtract, is_signed_b, std::move(op_b_binding),
+                        is_high_b ? Immediate(16) : Immediate(0), Immediate(16));
 
-    // TODO(Rodrigo): Use an appropiate sign for this operation
-    Node product = Operation(OperationCode::IMul, NO_PRECISE, op_a, op_b);
+    // we already check sign_a and sign_b is difference or not before so just use one in here.
+    Node product = SignedOperation(OperationCode::IMul, is_signed_a, op_a, op_b);
     if (is_psl) {
-        product = Operation(OperationCode::ILogicalShiftLeft, NO_PRECISE, product, Immediate(16));
+        product =
+            SignedOperation(OperationCode::ILogicalShiftLeft, is_signed_a, product, Immediate(16));
     }
     SetTemporary(bb, 0, product);
     product = GetTemporary(0);
@@ -88,12 +93,40 @@ u32 ShaderIR::DecodeXmad(NodeBlock& bb, u32 pc) {
             return BitfieldExtract(original_c, 16, 16);
         case Tegra::Shader::XmadMode::CBcc: {
             const Node shifted_b = SignedOperation(OperationCode::ILogicalShiftLeft, is_signed_b,
-                                                   NO_PRECISE, original_b, Immediate(16));
-            return SignedOperation(OperationCode::IAdd, is_signed_c, NO_PRECISE, original_c,
-                                   shifted_b);
+                                                   original_b, Immediate(16));
+            return SignedOperation(OperationCode::IAdd, is_signed_c, original_c, shifted_b);
+        }
+        case Tegra::Shader::XmadMode::CSfu: {
+            const Node comp_a = GetPredicateComparisonInteger(PredCondition::Equal, is_signed_a,
+                                                              op_a, Immediate(0));
+            const Node comp_b = GetPredicateComparisonInteger(PredCondition::Equal, is_signed_b,
+                                                              op_b, Immediate(0));
+            const Node comp = Operation(OperationCode::LogicalOr, comp_a, comp_b);
+
+            const Node comp_minus_a = GetPredicateComparisonInteger(
+                PredCondition::NotEqual, is_signed_a,
+                SignedOperation(OperationCode::IBitwiseAnd, is_signed_a, op_a,
+                                Immediate(0x80000000)),
+                Immediate(0));
+            const Node comp_minus_b = GetPredicateComparisonInteger(
+                PredCondition::NotEqual, is_signed_b,
+                SignedOperation(OperationCode::IBitwiseAnd, is_signed_b, op_b,
+                                Immediate(0x80000000)),
+                Immediate(0));
+
+            Node new_c = Operation(
+                OperationCode::Select, comp_minus_a,
+                SignedOperation(OperationCode::IAdd, is_signed_c, original_c, Immediate(-65536)),
+                original_c);
+            new_c = Operation(
+                OperationCode::Select, comp_minus_b,
+                SignedOperation(OperationCode::IAdd, is_signed_c, new_c, Immediate(-65536)),
+                std::move(new_c));
+
+            return Operation(OperationCode::Select, comp, original_c, std::move(new_c));
         }
         default:
-            UNIMPLEMENTED_MSG("Unhandled XMAD mode: {}", static_cast<u32>(instr.xmad.mode.Value()));
+            UNREACHABLE();
             return Immediate(0);
         }
     }();
@@ -102,18 +135,19 @@ u32 ShaderIR::DecodeXmad(NodeBlock& bb, u32 pc) {
     op_c = GetTemporary(1);
 
     // TODO(Rodrigo): Use an appropiate sign for this operation
-    Node sum = Operation(OperationCode::IAdd, product, op_c);
+    Node sum = SignedOperation(OperationCode::IAdd, is_signed_a, product, std::move(op_c));
     SetTemporary(bb, 2, sum);
     sum = GetTemporary(2);
     if (is_merge) {
-        const Node a = BitfieldExtract(sum, 0, 16);
-        const Node b =
-            Operation(OperationCode::ILogicalShiftLeft, NO_PRECISE, original_b, Immediate(16));
-        sum = Operation(OperationCode::IBitwiseOr, NO_PRECISE, a, b);
+        const Node a = SignedOperation(OperationCode::IBitfieldExtract, is_signed_a, std::move(sum),
+                                       Immediate(0), Immediate(16));
+        const Node b = SignedOperation(OperationCode::ILogicalShiftLeft, is_signed_b, original_b,
+                                       Immediate(16));
+        sum = SignedOperation(OperationCode::IBitwiseOr, is_signed_a, a, b);
     }
 
     SetInternalFlagsFromInteger(bb, sum, instr.generates_cc);
-    SetRegister(bb, instr.gpr0, sum);
+    SetRegister(bb, instr.gpr0, std::move(sum));
 
     return pc;
 }

src/video_core/shader/shader_ir.cpp

@@ -96,6 +96,7 @@ Node ShaderIR::GetPredicate(bool immediate) {
 }
 
 Node ShaderIR::GetInputAttribute(Attribute::Index index, u64 element, Node buffer) {
+    MarkAttributeUsage(index, element);
     used_input_attributes.emplace(index);
     return MakeNode<AbufNode>(index, static_cast<u32>(element), std::move(buffer));
 }
@@ -106,42 +107,8 @@ Node ShaderIR::GetPhysicalInputAttribute(Tegra::Shader::Register physical_addres
 }
 
 Node ShaderIR::GetOutputAttribute(Attribute::Index index, u64 element, Node buffer) {
-    if (index == Attribute::Index::LayerViewportPointSize) {
-        switch (element) {
-        case 0:
-            UNIMPLEMENTED();
-            break;
-        case 1:
-            uses_layer = true;
-            break;
-        case 2:
-            uses_viewport_index = true;
-            break;
-        case 3:
-            uses_point_size = true;
-            break;
-        }
-    }
-    if (index == Attribute::Index::TessCoordInstanceIDVertexID) {
-        switch (element) {
-        case 2:
-            uses_instance_id = true;
-            break;
-        case 3:
-            uses_vertex_id = true;
-            break;
-        default:
-            break;
-        }
-    }
-    if (index == Attribute::Index::ClipDistances0123 ||
-        index == Attribute::Index::ClipDistances4567) {
-        const auto clip_index =
-            static_cast<u32>((index == Attribute::Index::ClipDistances4567 ? 1 : 0) + element);
-        used_clip_distances.at(clip_index) = true;
-    }
+    MarkAttributeUsage(index, element);
     used_output_attributes.insert(index);
-
     return MakeNode<AbufNode>(index, static_cast<u32>(element), std::move(buffer));
 }
 
@@ -452,6 +419,54 @@ Node ShaderIR::BitfieldInsert(Node base, Node insert, u32 offset, u32 bits) {
                      Immediate(bits));
 }
 
+void ShaderIR::MarkAttributeUsage(Attribute::Index index, u64 element) {
+    switch (index) {
+    case Attribute::Index::LayerViewportPointSize:
+        switch (element) {
+        case 0:
+            UNIMPLEMENTED();
+            break;
+        case 1:
+            uses_layer = true;
+            break;
+        case 2:
+            uses_viewport_index = true;
+            break;
+        case 3:
+            uses_point_size = true;
+            break;
+        }
+        break;
+    case Attribute::Index::TessCoordInstanceIDVertexID:
+        switch (element) {
+        case 2:
+            uses_instance_id = true;
+            break;
+        case 3:
+            uses_vertex_id = true;
+            break;
+        }
+        break;
+    case Attribute::Index::ClipDistances0123:
+    case Attribute::Index::ClipDistances4567: {
+        const u64 clip_index = (index == Attribute::Index::ClipDistances4567 ? 4 : 0) + element;
+        used_clip_distances.at(clip_index) = true;
+        break;
+    }
+    case Attribute::Index::FrontColor:
+    case Attribute::Index::FrontSecondaryColor:
+    case Attribute::Index::BackColor:
+    case Attribute::Index::BackSecondaryColor:
+        uses_legacy_varyings = true;
+        break;
+    default:
+        if (index >= Attribute::Index::TexCoord_0 && index <= Attribute::Index::TexCoord_7) {
+            uses_legacy_varyings = true;
+        }
+        break;
+    }
+}
+
 std::size_t ShaderIR::DeclareAmend(Node new_amend) {
     const std::size_t id = amend_code.size();
     amend_code.push_back(new_amend);

src/video_core/shader/shader_ir.h

@@ -137,6 +137,10 @@ public:
         return uses_vertex_id;
     }
 
+    bool UsesLegacyVaryings() const {
+        return uses_legacy_varyings;
+    }
+
     bool UsesWarps() const {
         return uses_warps;
     }
@@ -343,6 +347,9 @@ private:
     /// Inserts a sequence of bits from a node
     Node BitfieldInsert(Node base, Node insert, u32 offset, u32 bits);
 
+    /// Marks the usage of a input or output attribute.
+    void MarkAttributeUsage(Tegra::Shader::Attribute::Index index, u64 element);
+
     void WriteTexInstructionFloat(NodeBlock& bb, Tegra::Shader::Instruction instr,
                                   const Node4& components);
 
@@ -443,6 +450,7 @@ private:
     bool uses_physical_attributes{}; // Shader uses AL2P or physical attribute read/writes
     bool uses_instance_id{};
     bool uses_vertex_id{};
+    bool uses_legacy_varyings{};
     bool uses_warps{};
     bool uses_indexed_samplers{};
 

src/yuzu/configuration/config.cpp

@@ -539,7 +539,7 @@ void Config::ReadDebuggingValues() {
 void Config::ReadServiceValues() {
     qt_config->beginGroup(QStringLiteral("Services"));
     Settings::values.bcat_backend =
-        ReadSetting(QStringLiteral("bcat_backend"), QStringLiteral("boxcat"))
+        ReadSetting(QStringLiteral("bcat_backend"), QStringLiteral("null"))
             .toString()
             .toStdString();
     Settings::values.bcat_boxcat_local =
@@ -682,6 +682,8 @@ void Config::ReadSystemValues() {
 
     Settings::values.language_index = ReadSetting(QStringLiteral("language_index"), 1).toInt();
 
+    Settings::values.region_index = ReadSetting(QStringLiteral("region_index"), 1).toInt();
+
     const auto rng_seed_enabled = ReadSetting(QStringLiteral("rng_seed_enabled"), false).toBool();
     if (rng_seed_enabled) {
         Settings::values.rng_seed = ReadSetting(QStringLiteral("rng_seed"), 0).toULongLong();
@@ -698,6 +700,8 @@ void Config::ReadSystemValues() {
         Settings::values.custom_rtc = std::nullopt;
     }
 
+    Settings::values.sound_index = ReadSetting(QStringLiteral("sound_index"), 1).toInt();
+
     qt_config->endGroup();
 }
 
@@ -1114,6 +1118,7 @@ void Config::SaveSystemValues() {
     WriteSetting(QStringLiteral("use_docked_mode"), Settings::values.use_docked_mode, false);
     WriteSetting(QStringLiteral("current_user"), Settings::values.current_user, 0);
     WriteSetting(QStringLiteral("language_index"), Settings::values.language_index, 1);
+    WriteSetting(QStringLiteral("region_index"), Settings::values.region_index, 1);
 
     WriteSetting(QStringLiteral("rng_seed_enabled"), Settings::values.rng_seed.has_value(), false);
     WriteSetting(QStringLiteral("rng_seed"), Settings::values.rng_seed.value_or(0), 0);
@@ -1125,6 +1130,8 @@ void Config::SaveSystemValues() {
                      Settings::values.custom_rtc.value_or(std::chrono::seconds{}).count()),
                  0);
 
+    WriteSetting(QStringLiteral("sound_index"), Settings::values.sound_index, 1);
+
     qt_config->endGroup();
 }
 

src/yuzu/configuration/configure_system.cpp

@@ -56,6 +56,8 @@ void ConfigureSystem::SetConfiguration() {
     enabled = !Core::System::GetInstance().IsPoweredOn();
 
     ui->combo_language->setCurrentIndex(Settings::values.language_index);
+    ui->combo_region->setCurrentIndex(Settings::values.region_index);
+    ui->combo_sound->setCurrentIndex(Settings::values.sound_index);
 
     ui->rng_seed_checkbox->setChecked(Settings::values.rng_seed.has_value());
     ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.has_value());
@@ -81,6 +83,8 @@ void ConfigureSystem::ApplyConfiguration() {
     }
 
     Settings::values.language_index = ui->combo_language->currentIndex();
+    Settings::values.region_index = ui->combo_region->currentIndex();
+    Settings::values.sound_index = ui->combo_sound->currentIndex();
 
     if (ui->rng_seed_checkbox->isChecked()) {
         Settings::values.rng_seed = ui->rng_seed_edit->text().toULongLong(nullptr, 16);

src/yuzu/configuration/configure_system.h

@@ -36,5 +36,6 @@ private:
     bool enabled = false;
 
     int language_index = 0;
+    int region_index = 0;
     int sound_index = 0;
 };

src/yuzu/configuration/configure_system.ui

@@ -22,14 +22,14 @@
         <string>System Settings</string>
        </property>
        <layout class="QGridLayout" name="gridLayout">
-        <item row="1" column="0">
+        <item row="2" column="0">
          <widget class="QLabel" name="label_sound">
           <property name="text">
            <string>Sound output mode</string>
           </property>
          </widget>
         </item>
-        <item row="2" column="0">
+        <item row="3" column="0">
          <widget class="QLabel" name="label_console_id">
           <property name="text">
            <string>Console ID:</string>
@@ -128,14 +128,60 @@
           </item>
          </widget>
         </item>
-        <item row="4" column="0">
+        <item row="1" column="0">
+         <widget class="QLabel" name="label_region">
+          <property name="text">
+           <string>Region:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="QComboBox" name="combo_region">
+          <item>
+           <property name="text">
+            <string>Japan</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>USA</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Europe</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Australia</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>China</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Korea</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Taiwan</string>
+           </property>
+          </item>
+         </widget>
+        </item>
+        <item row="5" column="0">
          <widget class="QCheckBox" name="rng_seed_checkbox">
           <property name="text">
            <string>RNG Seed</string>
           </property>
          </widget>
         </item>
-        <item row="1" column="1">
+        <item row="2" column="1">
          <widget class="QComboBox" name="combo_sound">
           <item>
            <property name="text">
@@ -161,7 +207,7 @@
           </property>
          </widget>
         </item>
-        <item row="2" column="1">
+        <item row="3" column="1">
          <widget class="QPushButton" name="button_regenerate_console_id">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
@@ -177,14 +223,14 @@
           </property>
          </widget>
         </item>
-        <item row="3" column="0">
+        <item row="4" column="0">
          <widget class="QCheckBox" name="custom_rtc_checkbox">
           <property name="text">
            <string>Custom RTC</string>
           </property>
          </widget>
         </item>
-        <item row="3" column="1">
+        <item row="4" column="1">
          <widget class="QDateTimeEdit" name="custom_rtc_edit">
           <property name="minimumDate">
            <date>
@@ -198,7 +244,7 @@
           </property>
          </widget>
         </item>
-        <item row="4" column="1">
+        <item row="5" column="1">
          <widget class="QLineEdit" name="rng_seed_edit">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Fixed">

src/yuzu_cmd/config.cpp

@@ -452,7 +452,7 @@ void Config::ReadValues() {
     Settings::values.yuzu_token = sdl2_config->Get("WebService", "yuzu_token", "");
 
     // Services
-    Settings::values.bcat_backend = sdl2_config->Get("Services", "bcat_backend", "boxcat");
+    Settings::values.bcat_backend = sdl2_config->Get("Services", "bcat_backend", "null");
     Settings::values.bcat_boxcat_local =
         sdl2_config->GetBoolean("Services", "bcat_boxcat_local", false);
 }