hle_ipc: Refactor ReadBuffer to set buffer size upon initialization

Initializing the vector size during initialization is more efficient than a later call to resize()

CMakeLists.txt

@@ -22,6 +22,8 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON
 # On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
 CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)
 
+option(ENABLE_OPENGL "Enable OpenGL" ON)
+mark_as_advanced(FORCE ENABLE_OPENGL)
 option(ENABLE_QT "Enable the Qt frontend" ON)
 option(ENABLE_QT6 "Allow usage of Qt6 to be attempted" OFF)
 set(QT6_LOCATION "" CACHE PATH "Additional Location to search for Qt6 libraries like C:/Qt/6.3.1/msvc2019_64/")
@@ -31,8 +33,6 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSV
 
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
-option(YUZU_USE_BUNDLED_LIBUSB "Compile bundled libusb" OFF)
-
 option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")
 
 option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)
@@ -53,6 +53,8 @@ option(YUZU_USE_BUNDLED_VCPKG "Use vcpkg for yuzu dependencies" "${MSVC}")
 
 option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ON)
 
+CMAKE_DEPENDENT_OPTION(YUZU_USE_FASTER_LD "Check if a faster linker is available" ON "NOT WIN32" OFF)
+
 if (YUZU_USE_BUNDLED_VCPKG)
     if (YUZU_TESTS)
         list(APPEND VCPKG_MANIFEST_FEATURES "yuzu-tests")
@@ -202,6 +204,7 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 find_package(enet 1.3)
 find_package(fmt 9 REQUIRED)
 find_package(inih)
+find_package(libusb 1.0.24)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
 find_package(Opus 1.3)
@@ -214,7 +217,7 @@ if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
 endif()
 
 if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
-    find_package(dynarmic 6.2.4)
+    find_package(dynarmic 6.4.0)
 endif()
 
 if (ENABLE_CUBEB)
@@ -433,23 +436,13 @@ if (ENABLE_SDL2)
         set(SDL2_LIBRARY "${SDL2_PREFIX}/lib/x64/SDL2.lib" CACHE PATH "Path to SDL2 library")
         set(SDL2_DLL_DIR "${SDL2_PREFIX}/lib/x64/" CACHE PATH "Path to SDL2.dll")
 
-        add_library(SDL2 INTERFACE)
-        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARY}")
-        target_include_directories(SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
+        add_library(SDL2::SDL2 INTERFACE IMPORTED)
+        target_link_libraries(SDL2::SDL2 INTERFACE "${SDL2_LIBRARY}")
+        target_include_directories(SDL2::SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
     elseif (YUZU_USE_EXTERNAL_SDL2)
         message(STATUS "Using SDL2 from externals.")
     else()
         find_package(SDL2 2.0.18 REQUIRED)
-
-        # Some installations don't set SDL2_LIBRARIES
-        if("${SDL2_LIBRARIES}" STREQUAL "")
-            message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
-            set(SDL2_LIBRARIES "SDL2::SDL2")
-        endif()
-
-        include_directories(SYSTEM ${SDL2_INCLUDE_DIRS})
-        add_library(SDL2 INTERFACE)
-        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
     endif()
 endif()
 
@@ -461,26 +454,6 @@ if (TARGET Boost::boost)
     add_library(boost ALIAS Boost::boost)
 endif()
 
-# Ensure libusb is properly configured (based on dolphin libusb include)
-if(NOT YUZU_USE_BUNDLED_LIBUSB)
-    find_package(PkgConfig)
-    if (PKG_CONFIG_FOUND AND NOT CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD")
-        pkg_check_modules(LIBUSB QUIET libusb-1.0>=1.0.24)
-    else()
-        find_package(LibUSB)
-    endif()
-
-    if (LIBUSB_FOUND)
-        add_library(usb INTERFACE)
-        target_include_directories(usb INTERFACE "${LIBUSB_INCLUDEDIR}" "${LIBUSB_INCLUDE_DIRS}")
-        target_link_directories(usb INTERFACE "${LIBUSB_LIBRARY_DIRS}")
-        target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARIES}")
-    else()
-        message(WARNING "libusb not found, falling back to externals")
-        set(YUZU_USE_BUNDLED_LIBUSB ON)
-    endif()
-endif()
-
 # List of all FFmpeg components required
 set(FFmpeg_COMPONENTS
     avcodec
@@ -610,6 +583,21 @@ if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
     )
 endif()
 
+if (YUZU_USE_FASTER_LD AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # We will assume that if the compiler is GCC, it will attempt to use ld.bfd by default.
+    # Try to pick a faster linker.
+    find_program(LLD lld)
+    find_program(MOLD mold)
+
+    if (MOLD AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.1")
+        message(NOTICE "Selecting mold as linker")
+        add_link_options("-fuse-ld=mold")
+    elseif (LLD)
+        message(NOTICE "Selecting lld as linker")
+        add_link_options("-fuse-ld=lld")
+    endif()
+endif()
+
 enable_testing()
 add_subdirectory(externals)
 add_subdirectory(src)

externals/CMakeLists.txt

@@ -45,8 +45,8 @@ if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12" AND CMAKE_CXX_COMPILER
 endif()
 
 # libusb
-if (NOT LIBUSB_FOUND OR YUZU_USE_BUNDLED_LIBUSB)
-    add_subdirectory(libusb)
+if (NOT TARGET libusb::usb)
+    add_subdirectory(libusb EXCLUDE_FROM_ALL)
 endif()
 
 # SDL2

externals/find-modules/FindLibUSB.cmake

@@ -1,44 +0,0 @@
-# SPDX-FileCopyrightText: 2009 Michal Cihar <michal@cihar.com>
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-# - Find libusb-1.0 library
-# This module defines
-#  LIBUSB_INCLUDE_DIR, where to find bluetooth.h
-#  LIBUSB_LIBRARIES, the libraries needed to use libusb-1.0.
-#  LIBUSB_FOUND, If false, do not try to use libusb-1.0.
-#
-# vim: expandtab sw=4 ts=4 sts=4:
-
-if(ANDROID)
-       set(LIBUSB_FOUND FALSE CACHE INTERNAL "libusb-1.0 found")
-       message(STATUS "libusb-1.0 not found.")
-elseif (NOT LIBUSB_FOUND)
-    pkg_check_modules (LIBUSB_PKG libusb-1.0)
-
-    find_path(LIBUSB_INCLUDE_DIR NAMES libusb.h
-       PATHS
-       ${LIBUSB_PKG_INCLUDE_DIRS}
-       /usr/include/libusb-1.0
-       /usr/include
-       /usr/local/include/libusb-1.0
-       /usr/local/include
-    )
-
-    find_library(LIBUSB_LIBRARIES NAMES usb-1.0 usb
-       PATHS
-       ${LIBUSB_PKG_LIBRARY_DIRS}
-       /usr/lib
-       /usr/local/lib
-    )
-
-    if(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-       set(LIBUSB_FOUND TRUE CACHE INTERNAL "libusb-1.0 found")
-       message(STATUS "Found libusb-1.0: ${LIBUSB_INCLUDE_DIR}, ${LIBUSB_LIBRARIES}")
-    else(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-       set(LIBUSB_FOUND FALSE CACHE INTERNAL "libusb-1.0 found")
-       message(STATUS "libusb-1.0 not found.")
-    endif(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-
-    mark_as_advanced(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARIES)
-endif ()
-

externals/find-modules/FindOpus.cmake

@@ -1,19 +1,15 @@
 # SPDX-FileCopyrightText: 2022 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-find_package(PkgConfig)
-
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(opus IMPORTED_TARGET GLOBAL opus)
-    if (opus_FOUND)
-        add_library(Opus::opus ALIAS PkgConfig::opus)
-    endif()
-endif()
+find_package(PkgConfig QUIET)
+pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Opus
-    REQUIRED_VARS
-        opus_LINK_LIBRARIES
-        opus_FOUND
-    VERSION_VAR opus_VERSION
+    REQUIRED_VARS OPUS_LINK_LIBRARIES
+    VERSION_VAR OPUS_VERSION
 )
+
+if (Opus_FOUND AND NOT TARGET Opus::opus)
+    add_library(Opus::opus ALIAS PkgConfig::OPUS)
+endif()

externals/find-modules/Findenet.cmake

@@ -3,15 +3,14 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(ENET QUIET IMPORTED_TARGET GLOBAL libenet)
-    if (ENET_FOUND)
-        add_library(enet::enet ALIAS PkgConfig::ENET)
-    endif()
-endif()
+pkg_search_module(ENET QUIET IMPORTED_TARGET libenet)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(enet
     REQUIRED_VARS ENET_LINK_LIBRARIES
     VERSION_VAR ENET_VERSION
 )
+
+if (enet_FOUND AND NOT TARGET enet::enet)
+    add_library(enet::enet ALIAS PkgConfig::ENET)
+endif()

externals/find-modules/Findhttplib.cmake

@@ -9,14 +9,13 @@ if (httplib_FOUND)
     find_package_handle_standard_args(httplib CONFIG_MODE)
 else()
     find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(HTTPLIB QUIET IMPORTED_TARGET GLOBAL cpp-httplib)
-        if (HTTPLIB_FOUND)
-            add_library(httplib::httplib ALIAS PkgConfig::HTTPLIB)
-        endif()
-    endif()
+    pkg_search_module(HTTPLIB QUIET IMPORTED_TARGET cpp-httplib)
     find_package_handle_standard_args(httplib
         REQUIRED_VARS HTTPLIB_INCLUDEDIR
         VERSION_VAR HTTPLIB_VERSION
     )
 endif()
+
+if (httplib_FOUND AND NOT TARGET httplib::httplib)
+    add_library(httplib::httplib ALIAS PkgConfig::HTTPLIB)
+endif()

externals/find-modules/Findinih.cmake

@@ -3,15 +3,14 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(INIREADER QUIET IMPORTED_TARGET GLOBAL INIReader)
-    if (INIREADER_FOUND)
-        add_library(inih::INIReader ALIAS PkgConfig::INIREADER)
-    endif()
-endif()
+pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(inih
     REQUIRED_VARS INIREADER_LINK_LIBRARIES
     VERSION_VAR INIREADER_VERSION
 )
+
+if (inih_FOUND AND NOT TARGET inih::INIReader)
+    add_library(inih::INIReader ALIAS PkgConfig::INIREADER)
+endif()

externals/find-modules/Findlibusb.cmake

@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: 2022 Alexandre Bouvier <contact@amb.tf>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+find_package(PkgConfig QUIET)
+pkg_search_module(LIBUSB QUIET IMPORTED_TARGET libusb-1.0)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(libusb
+    REQUIRED_VARS LIBUSB_LINK_LIBRARIES
+    VERSION_VAR LIBUSB_VERSION
+)
+
+if (libusb_FOUND AND NOT TARGET libusb::usb)
+    add_library(libusb::usb ALIAS PkgConfig::LIBUSB)
+endif()

externals/find-modules/Findlz4.cmake

@@ -6,25 +6,21 @@ include(FindPackageHandleStandardArgs)
 find_package(lz4 QUIET CONFIG)
 if (lz4_FOUND)
     find_package_handle_standard_args(lz4 CONFIG_MODE)
-    if (NOT TARGET lz4::lz4)
-        if (TARGET LZ4::lz4_shared)
-            set_target_properties(LZ4::lz4_shared PROPERTIES IMPORTED_GLOBAL TRUE)
-            add_library(lz4::lz4 ALIAS LZ4::lz4_shared)
-        else()
-            set_target_properties(LZ4::lz4_static PROPERTIES IMPORTED_GLOBAL TRUE)
-            add_library(lz4::lz4 ALIAS LZ4::lz4_static)
-        endif()
-    endif()
 else()
     find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(liblz4 QUIET IMPORTED_TARGET GLOBAL liblz4)
-        if (liblz4_FOUND)
-            add_library(lz4::lz4 ALIAS PkgConfig::liblz4)
-        endif()
-    endif()
+    pkg_search_module(LZ4 QUIET IMPORTED_TARGET liblz4)
     find_package_handle_standard_args(lz4
-        REQUIRED_VARS liblz4_LINK_LIBRARIES
-        VERSION_VAR liblz4_VERSION
+        REQUIRED_VARS LZ4_LINK_LIBRARIES
+        VERSION_VAR LZ4_VERSION
     )
 endif()
+
+if (lz4_FOUND AND NOT TARGET lz4::lz4)
+    if (TARGET LZ4::lz4_shared)
+        add_library(lz4::lz4 ALIAS LZ4::lz4_shared)
+    elseif (TARGET LZ4::lz4_static)
+        add_library(lz4::lz4 ALIAS LZ4::lz4_static)
+    else()
+        add_library(lz4::lz4 ALIAS PkgConfig::LZ4)
+    endif()
+endif()

externals/find-modules/Findzstd.cmake

@@ -6,25 +6,21 @@ include(FindPackageHandleStandardArgs)
 find_package(zstd QUIET CONFIG)
 if (zstd_FOUND)
     find_package_handle_standard_args(zstd CONFIG_MODE)
-    if (NOT TARGET zstd::zstd)
-        if (TARGET zstd::libzstd_shared)
-            set_target_properties(zstd::libzstd_shared PROPERTIES IMPORTED_GLOBAL TRUE)
-            add_library(zstd::zstd ALIAS zstd::libzstd_shared)
-        else()
-            set_target_properties(zstd::libzstd_static PROPERTIES IMPORTED_GLOBAL TRUE)
-            add_library(zstd::zstd ALIAS zstd::libzstd_static)
-        endif()
-    endif()
 else()
     find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(libzstd QUIET IMPORTED_TARGET GLOBAL libzstd)
-        if (libzstd_FOUND)
-            add_library(zstd::zstd ALIAS PkgConfig::libzstd)
-        endif()
-    endif()
+    pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
     find_package_handle_standard_args(zstd
-        REQUIRED_VARS libzstd_LINK_LIBRARIES
-        VERSION_VAR libzstd_VERSION
+        REQUIRED_VARS ZSTD_LINK_LIBRARIES
+        VERSION_VAR ZSTD_VERSION
     )
 endif()
+
+if (zstd_FOUND AND NOT TARGET zstd::zstd)
+    if (TARGET zstd::libzstd_shared)
+        add_library(zstd::zstd ALIAS zstd::libzstd_shared)
+    elseif (TARGET zstd::libzstd_static)
+        add_library(zstd::zstd ALIAS zstd::libzstd_static)
+    else()
+        add_library(zstd::zstd ALIAS PkgConfig::ZSTD)
+    endif()
+endif()

externals/libusb/CMakeLists.txt

@@ -273,3 +273,5 @@ else() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 
     configure_file(config.h.in config.h)
 endif() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+
+add_library(libusb::usb ALIAS usb)

src/audio_core/CMakeLists.txt

@@ -227,11 +227,7 @@ if(ENABLE_CUBEB)
     target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
 if(ENABLE_SDL2)
-    if (YUZU_USE_EXTERNAL_SDL2)
-        target_link_libraries(audio_core PRIVATE SDL2-static)
-    else()
-        target_link_libraries(audio_core PRIVATE SDL2)
-    endif()
+    target_link_libraries(audio_core PRIVATE SDL2::SDL2)
     target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()
 

src/audio_core/renderer/performance/detail_aspect.h

@@ -16,7 +16,6 @@ class CommandGenerator;
  */
 class DetailAspect {
 public:
-    DetailAspect() = default;
     DetailAspect(CommandGenerator& command_generator, PerformanceEntryType entry_type, s32 node_id,
                  PerformanceDetailType detail_type);
 

src/audio_core/renderer/performance/entry_aspect.h

@@ -16,7 +16,6 @@ class CommandGenerator;
  */
 class EntryAspect {
 public:
-    EntryAspect() = default;
     EntryAspect(CommandGenerator& command_generator, PerformanceEntryType type, s32 node_id);
 
     /// Command generator the command will be generated into

src/common/CMakeLists.txt

@@ -34,8 +34,6 @@ add_library(common STATIC
     bit_util.h
     cityhash.cpp
     cityhash.h
-    cache_management.cpp
-    cache_management.h
     common_funcs.h
     common_precompiled_headers.h
     common_types.h

src/common/cache_management.cpp

@@ -1,59 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <cstdint>
-#include <cstring>
-
-#include "common/cache_management.h"
-
-namespace Common {
-
-#if defined(ARCHITECTURE_x86_64)
-
-// Most cache operations are no-ops on x86
-
-void DataCacheLineCleanByVAToPoU(void* start, size_t size) {}
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size) {}
-void DataCacheLineCleanByVAToPoC(void* start, size_t size) {}
-void DataCacheZeroByVA(void* start, size_t size) {
-    std::memset(start, 0, size);
-}
-
-#elif defined(ARCHITECTURE_arm64)
-
-// BS/DminLine is log2(cache size in words), we want size in bytes
-#define EXTRACT_DMINLINE(ctr_el0) (1 << ((((ctr_el0) >> 16) & 0xf) + 2))
-#define EXTRACT_BS(dczid_el0) (1 << (((dczid_el0)&0xf) + 2))
-
-#define DEFINE_DC_OP(op_name, function_name)                                                       \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t ctr_el0;                                                                            \
-        asm volatile("mrs %[ctr_el0], ctr_el0\n\t" : [ctr_el0] "=r"(ctr_el0));                     \
-        size_t cacheline_size = EXTRACT_DMINLINE(ctr_el0);                                         \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-#define DEFINE_DC_OP_DCZID(op_name, function_name)                                                 \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t dczid_el0;                                                                          \
-        asm volatile("mrs %[dczid_el0], dczid_el0\n\t" : [dczid_el0] "=r"(dczid_el0));             \
-        size_t cacheline_size = EXTRACT_BS(dczid_el0);                                             \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-DEFINE_DC_OP(cvau, DataCacheLineCleanByVAToPoU);
-DEFINE_DC_OP(civac, DataCacheLineCleanAndInvalidateByVAToPoC);
-DEFINE_DC_OP(cvac, DataCacheLineCleanByVAToPoC);
-DEFINE_DC_OP_DCZID(zva, DataCacheZeroByVA);
-
-#endif
-
-} // namespace Common

src/common/cache_management.h

@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <cstddef>
-
-namespace Common {
-
-// Data cache instructions enabled at EL0 by SCTLR_EL1.UCI.
-// VA = virtual address
-// PoC = point of coherency
-// PoU = point of unification
-
-// dc cvau
-void DataCacheLineCleanByVAToPoU(void* start, size_t size);
-
-// dc civac
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size);
-
-// dc cvac
-void DataCacheLineCleanByVAToPoC(void* start, size_t size);
-
-// dc zva
-void DataCacheZeroByVA(void* start, size_t size);
-
-} // namespace Common

src/common/settings.h

@@ -76,7 +76,8 @@ enum class ScalingFilter : u32 {
 enum class AntiAliasing : u32 {
     None = 0,
     Fxaa = 1,
-    LastAA = Fxaa,
+    Smaa = 2,
+    LastAA = Smaa,
 };
 
 struct ResolutionScalingInfo {
@@ -400,6 +401,7 @@ struct Values {
     Setting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
     Setting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"};
     Setting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"};
+    Setting<bool> cpuopt_ignore_memory_aborts{true, "cpuopt_ignore_memory_aborts"};
 
     SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
     SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};

src/common/thread.h

@@ -11,6 +11,7 @@
 #include <mutex>
 #include <thread>
 #include "common/common_types.h"
+#include "common/polyfill_thread.h"
 
 namespace Common {
 
@@ -69,7 +70,7 @@ public:
     explicit Barrier(std::size_t count_) : count(count_) {}
 
     /// Blocks until all "count" threads have called Sync()
-    void Sync() {
+    bool Sync(std::stop_token token = {}) {
         std::unique_lock lk{mutex};
         const std::size_t current_generation = generation;
 
@@ -77,14 +78,16 @@ public:
             generation++;
             waiting = 0;
             condvar.notify_all();
+            return true;
         } else {
-            condvar.wait(lk,
-                         [this, current_generation] { return current_generation != generation; });
+            CondvarWait(condvar, lk, token,
+                        [this, current_generation] { return current_generation != generation; });
+            return !token.stop_requested();
         }
     }
 
 private:
-    std::condition_variable condvar;
+    std::condition_variable_any condvar;
     std::mutex mutex;
     std::size_t count;
     std::size_t waiting = 0;

src/core/CMakeLists.txt

@@ -528,6 +528,8 @@ add_library(core STATIC
     hle/service/mnpp/mnpp_app.h
     hle/service/ncm/ncm.cpp
     hle/service/ncm/ncm.h
+    hle/service/nfc/mifare_user.cpp
+    hle/service/nfc/mifare_user.h
     hle/service/nfc/nfc.cpp
     hle/service/nfc/nfc.h
     hle/service/nfc/nfc_device.cpp

src/core/arm/arm_interface.cpp

@@ -145,11 +145,15 @@ void ARM_Interface::Run() {
         // Notify the debugger and go to sleep if a breakpoint was hit,
         // or if the thread is unable to continue for any reason.
         if (Has(hr, breakpoint) || Has(hr, no_execute)) {
-            RewindBreakpointInstruction();
+            if (!Has(hr, no_execute)) {
+                RewindBreakpointInstruction();
+            }
             if (system.DebuggerEnabled()) {
                 system.GetDebugger().NotifyThreadStopped(current_thread);
+            } else {
+                LogBacktrace();
             }
-            current_thread->RequestSuspend(Kernel::SuspendType::Debug);
+            current_thread->RequestSuspend(SuspendType::Debug);
             break;
         }
 

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -29,7 +29,9 @@ class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
     explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_)
         : parent{parent_},
-          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()} {}
+          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()},
+          check_memory_access{debugger_enabled ||
+                              !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
 
     u8 MemoryRead8(u32 vaddr) override {
         CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
@@ -154,6 +156,17 @@ public:
     }
 
     bool CheckMemoryAccess(VAddr addr, u64 size, Kernel::DebugWatchpointType type) {
+        if (!check_memory_access) {
+            return true;
+        }
+
+        if (!memory.IsValidVirtualAddressRange(addr, size)) {
+            LOG_CRITICAL(Core_ARM, "Stopping execution due to unmapped memory access at {:#x}",
+                         addr);
+            parent.jit.load()->HaltExecution(ARM_Interface::no_execute);
+            return false;
+        }
+
         if (!debugger_enabled) {
             return true;
         }
@@ -181,7 +194,8 @@ public:
     ARM_Dynarmic_32& parent;
     Core::Memory::Memory& memory;
     std::size_t num_interpreted_instructions{};
-    bool debugger_enabled{};
+    const bool debugger_enabled{};
+    const bool check_memory_access{};
     static constexpr u64 minimum_run_cycles = 10000U;
 };
 
@@ -264,6 +278,9 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_recompile_exclusives) {
             config.recompile_on_exclusive_fastmem_failure = false;
         }
+        if (!Settings::values.cpuopt_ignore_memory_aborts) {
+            config.check_halt_on_memory_access = true;
+        }
     } else {
         // Unsafe optimizations
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -29,7 +29,9 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
     explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_)
         : parent{parent_},
-          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()} {}
+          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()},
+          check_memory_access{debugger_enabled ||
+                              !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
 
     u8 MemoryRead8(u64 vaddr) override {
         CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
@@ -198,6 +200,17 @@ public:
     }
 
     bool CheckMemoryAccess(VAddr addr, u64 size, Kernel::DebugWatchpointType type) {
+        if (!check_memory_access) {
+            return true;
+        }
+
+        if (!memory.IsValidVirtualAddressRange(addr, size)) {
+            LOG_CRITICAL(Core_ARM, "Stopping execution due to unmapped memory access at {:#x}",
+                         addr);
+            parent.jit.load()->HaltExecution(ARM_Interface::no_execute);
+            return false;
+        }
+
         if (!debugger_enabled) {
             return true;
         }
@@ -226,7 +239,8 @@ public:
     Core::Memory::Memory& memory;
     u64 tpidrro_el0 = 0;
     u64 tpidr_el0 = 0;
-    bool debugger_enabled{};
+    const bool debugger_enabled{};
+    const bool check_memory_access{};
     static constexpr u64 minimum_run_cycles = 10000U;
 };
 
@@ -323,6 +337,9 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_recompile_exclusives) {
             config.recompile_on_exclusive_fastmem_failure = false;
         }
+        if (!Settings::values.cpuopt_ignore_memory_aborts) {
+            config.check_halt_on_memory_access = true;
+        }
     } else {
         // Unsafe optimizations
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {

src/core/core.cpp

@@ -389,7 +389,9 @@ struct System::Impl {
         kernel.ShutdownCores();
         cpu_manager.Shutdown();
         debugger.reset();
-        services->KillNVNFlinger();
+        if (services) {
+            services->KillNVNFlinger();
+        }
         kernel.CloseServices();
         services.reset();
         service_manager.reset();

src/core/cpu_manager.cpp

@@ -20,23 +20,20 @@ namespace Core {
 CpuManager::CpuManager(System& system_) : system{system_} {}
 CpuManager::~CpuManager() = default;
 
-void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
-                             std::size_t core) {
-    cpu_manager.RunThread(core);
-}
-
 void CpuManager::Initialize() {
     num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1;
     gpu_barrier = std::make_unique<Common::Barrier>(num_cores + 1);
 
     for (std::size_t core = 0; core < num_cores; core++) {
-        core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
+        core_data[core].host_thread =
+            std::jthread([this, core](std::stop_token token) { RunThread(token, core); });
     }
 }
 
 void CpuManager::Shutdown() {
     for (std::size_t core = 0; core < num_cores; core++) {
         if (core_data[core].host_thread.joinable()) {
+            core_data[core].host_thread.request_stop();
             core_data[core].host_thread.join();
         }
     }
@@ -184,7 +181,7 @@ void CpuManager::ShutdownThread() {
     UNREACHABLE();
 }
 
-void CpuManager::RunThread(std::size_t core) {
+void CpuManager::RunThread(std::stop_token token, std::size_t core) {
     /// Initialization
     system.RegisterCoreThread(core);
     std::string name;
@@ -206,7 +203,9 @@ void CpuManager::RunThread(std::size_t core) {
     });
 
     // Running
-    gpu_barrier->Sync();
+    if (!gpu_barrier->Sync(token)) {
+        return;
+    }
 
     if (!is_async_gpu && !is_multicore) {
         system.GPU().ObtainContext();

src/core/cpu_manager.h

@@ -81,12 +81,10 @@ private:
     void SingleCoreRunGuestThread();
     void SingleCoreRunIdleThread();
 
-    static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);
-
     void GuestActivate();
     void HandleInterrupt();
     void ShutdownThread();
-    void RunThread(std::size_t core);
+    void RunThread(std::stop_token stop_token, std::size_t core);
 
     struct CoreData {
         std::shared_ptr<Common::Fiber> host_context;

src/core/frontend/applets/controller.cpp

@@ -16,7 +16,7 @@ DefaultControllerApplet::DefaultControllerApplet(HID::HIDCore& hid_core_) : hid_
 
 DefaultControllerApplet::~DefaultControllerApplet() = default;
 
-void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callback,
+void DefaultControllerApplet::ReconfigureControllers(ReconfigureCallback callback,
                                                      const ControllerParameters& parameters) const {
     LOG_INFO(Service_HID, "called, deducing the best configuration based on the given parameters!");
 

src/core/frontend/applets/controller.h

@@ -36,9 +36,11 @@ struct ControllerParameters {
 
 class ControllerApplet {
 public:
+    using ReconfigureCallback = std::function<void()>;
+
     virtual ~ControllerApplet();
 
-    virtual void ReconfigureControllers(std::function<void()> callback,
+    virtual void ReconfigureControllers(ReconfigureCallback callback,
                                         const ControllerParameters& parameters) const = 0;
 };
 
@@ -47,7 +49,7 @@ public:
     explicit DefaultControllerApplet(HID::HIDCore& hid_core_);
     ~DefaultControllerApplet() override;
 
-    void ReconfigureControllers(std::function<void()> callback,
+    void ReconfigureControllers(ReconfigureCallback callback,
                                 const ControllerParameters& parameters) const override;
 
 private:

src/core/frontend/applets/error.cpp

@@ -8,13 +8,13 @@ namespace Core::Frontend {
 
 ErrorApplet::~ErrorApplet() = default;
 
-void DefaultErrorApplet::ShowError(Result error, std::function<void()> finished) const {
+void DefaultErrorApplet::ShowError(Result error, FinishedCallback finished) const {
     LOG_CRITICAL(Service_Fatal, "Application requested error display: {:04}-{:04} (raw={:08X})",
                  error.module.Value(), error.description.Value(), error.raw);
 }
 
 void DefaultErrorApplet::ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
-                                                std::function<void()> finished) const {
+                                                FinishedCallback finished) const {
     LOG_CRITICAL(
         Service_Fatal,
         "Application requested error display: {:04X}-{:04X} (raw={:08X}) with timestamp={:016X}",
@@ -23,7 +23,7 @@ void DefaultErrorApplet::ShowErrorWithTimestamp(Result error, std::chrono::secon
 
 void DefaultErrorApplet::ShowCustomErrorText(Result error, std::string main_text,
                                              std::string detail_text,
-                                             std::function<void()> finished) const {
+                                             FinishedCallback finished) const {
     LOG_CRITICAL(Service_Fatal,
                  "Application requested custom error with error_code={:04X}-{:04X} (raw={:08X})",
                  error.module.Value(), error.description.Value(), error.raw);

src/core/frontend/applets/error.h

@@ -12,25 +12,27 @@ namespace Core::Frontend {
 
 class ErrorApplet {
 public:
+    using FinishedCallback = std::function<void()>;
+
     virtual ~ErrorApplet();
 
-    virtual void ShowError(Result error, std::function<void()> finished) const = 0;
+    virtual void ShowError(Result error, FinishedCallback finished) const = 0;
 
     virtual void ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
-                                        std::function<void()> finished) const = 0;
+                                        FinishedCallback finished) const = 0;
 
     virtual void ShowCustomErrorText(Result error, std::string dialog_text,
                                      std::string fullscreen_text,
-                                     std::function<void()> finished) const = 0;
+                                     FinishedCallback finished) const = 0;
 };
 
 class DefaultErrorApplet final : public ErrorApplet {
 public:
-    void ShowError(Result error, std::function<void()> finished) const override;
+    void ShowError(Result error, FinishedCallback finished) const override;
     void ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
-                                std::function<void()> finished) const override;
+                                FinishedCallback finished) const override;
     void ShowCustomErrorText(Result error, std::string main_text, std::string detail_text,
-                             std::function<void()> finished) const override;
+                             FinishedCallback finished) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/mii_edit.cpp

@@ -8,7 +8,7 @@ namespace Core::Frontend {
 
 MiiEditApplet::~MiiEditApplet() = default;
 
-void DefaultMiiEditApplet::ShowMiiEdit(const std::function<void()>& callback) const {
+void DefaultMiiEditApplet::ShowMiiEdit(const MiiEditCallback& callback) const {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
     callback();

src/core/frontend/applets/mii_edit.h

@@ -9,14 +9,16 @@ namespace Core::Frontend {
 
 class MiiEditApplet {
 public:
+    using MiiEditCallback = std::function<void()>;
+
     virtual ~MiiEditApplet();
 
-    virtual void ShowMiiEdit(const std::function<void()>& callback) const = 0;
+    virtual void ShowMiiEdit(const MiiEditCallback& callback) const = 0;
 };
 
 class DefaultMiiEditApplet final : public MiiEditApplet {
 public:
-    void ShowMiiEdit(const std::function<void()>& callback) const override;
+    void ShowMiiEdit(const MiiEditCallback& callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/profile_select.cpp

@@ -9,8 +9,7 @@ namespace Core::Frontend {
 
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
-void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Common::UUID>)> callback) const {
+void DefaultProfileSelectApplet::SelectProfile(SelectProfileCallback callback) const {
     Service::Account::ProfileManager manager;
     callback(manager.GetUser(Settings::values.current_user.GetValue()).value_or(Common::UUID{}));
     LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");

src/core/frontend/applets/profile_select.h

@@ -11,14 +11,16 @@ namespace Core::Frontend {
 
 class ProfileSelectApplet {
 public:
+    using SelectProfileCallback = std::function<void(std::optional<Common::UUID>)>;
+
     virtual ~ProfileSelectApplet();
 
-    virtual void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const = 0;
+    virtual void SelectProfile(SelectProfileCallback callback) const = 0;
 };
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
-    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
+    void SelectProfile(SelectProfileCallback callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/software_keyboard.cpp

@@ -15,10 +15,7 @@ DefaultSoftwareKeyboardApplet::~DefaultSoftwareKeyboardApplet() = default;
 
 void DefaultSoftwareKeyboardApplet::InitializeKeyboard(
     bool is_inline, KeyboardInitializeParameters initialize_parameters,
-    std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-        submit_normal_callback_,
-    std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
-        submit_inline_callback_) {
+    SubmitNormalCallback submit_normal_callback_, SubmitInlineCallback submit_inline_callback_) {
     if (is_inline) {
         LOG_WARNING(
             Service_AM,

src/core/frontend/applets/software_keyboard.h

@@ -54,14 +54,17 @@ struct InlineTextParameters {
 
 class SoftwareKeyboardApplet {
 public:
+    using SubmitInlineCallback =
+        std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>;
+    using SubmitNormalCallback =
+        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>;
+
     virtual ~SoftwareKeyboardApplet();
 
-    virtual void InitializeKeyboard(
-        bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-            submit_normal_callback_,
-        std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
-            submit_inline_callback_) = 0;
+    virtual void InitializeKeyboard(bool is_inline,
+                                    KeyboardInitializeParameters initialize_parameters,
+                                    SubmitNormalCallback submit_normal_callback_,
+                                    SubmitInlineCallback submit_inline_callback_) = 0;
 
     virtual void ShowNormalKeyboard() const = 0;
 
@@ -81,12 +84,9 @@ class DefaultSoftwareKeyboardApplet final : public SoftwareKeyboardApplet {
 public:
     ~DefaultSoftwareKeyboardApplet() override;
 
-    void InitializeKeyboard(
-        bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-            submit_normal_callback_,
-        std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
-            submit_inline_callback_) override;
+    void InitializeKeyboard(bool is_inline, KeyboardInitializeParameters initialize_parameters,
+                            SubmitNormalCallback submit_normal_callback_,
+                            SubmitInlineCallback submit_inline_callback_) override;
 
     void ShowNormalKeyboard() const override;
 
@@ -105,12 +105,10 @@ private:
     void SubmitNormalText(std::u16string text) const;
     void SubmitInlineText(std::u16string_view text) const;
 
-    KeyboardInitializeParameters parameters;
+    KeyboardInitializeParameters parameters{};
 
-    mutable std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-        submit_normal_callback;
-    mutable std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
-        submit_inline_callback;
+    mutable SubmitNormalCallback submit_normal_callback;
+    mutable SubmitInlineCallback submit_inline_callback;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/web_browser.cpp

@@ -10,18 +10,17 @@ WebBrowserApplet::~WebBrowserApplet() = default;
 
 DefaultWebBrowserApplet::~DefaultWebBrowserApplet() = default;
 
-void DefaultWebBrowserApplet::OpenLocalWebPage(
-    const std::string& local_url, std::function<void()> extract_romfs_callback,
-    std::function<void(Service::AM::Applets::WebExitReason, std::string)> callback) const {
+void DefaultWebBrowserApplet::OpenLocalWebPage(const std::string& local_url,
+                                               ExtractROMFSCallback extract_romfs_callback,
+                                               OpenWebPageCallback callback) const {
     LOG_WARNING(Service_AM, "(STUBBED) called, backend requested to open local web page at {}",
                 local_url);
 
     callback(Service::AM::Applets::WebExitReason::WindowClosed, "http://localhost/");
 }
 
-void DefaultWebBrowserApplet::OpenExternalWebPage(
-    const std::string& external_url,
-    std::function<void(Service::AM::Applets::WebExitReason, std::string)> callback) const {
+void DefaultWebBrowserApplet::OpenExternalWebPage(const std::string& external_url,
+                                                  OpenWebPageCallback callback) const {
     LOG_WARNING(Service_AM, "(STUBBED) called, backend requested to open external web page at {}",
                 external_url);
 

src/core/frontend/applets/web_browser.h

@@ -11,29 +11,29 @@ namespace Core::Frontend {
 
 class WebBrowserApplet {
 public:
+    using ExtractROMFSCallback = std::function<void()>;
+    using OpenWebPageCallback =
+        std::function<void(Service::AM::Applets::WebExitReason, std::string)>;
+
     virtual ~WebBrowserApplet();
 
-    virtual void OpenLocalWebPage(
-        const std::string& local_url, std::function<void()> extract_romfs_callback,
-        std::function<void(Service::AM::Applets::WebExitReason, std::string)> callback) const = 0;
+    virtual void OpenLocalWebPage(const std::string& local_url,
+                                  ExtractROMFSCallback extract_romfs_callback,
+                                  OpenWebPageCallback callback) const = 0;
 
-    virtual void OpenExternalWebPage(
-        const std::string& external_url,
-        std::function<void(Service::AM::Applets::WebExitReason, std::string)> callback) const = 0;
+    virtual void OpenExternalWebPage(const std::string& external_url,
+                                     OpenWebPageCallback callback) const = 0;
 };
 
 class DefaultWebBrowserApplet final : public WebBrowserApplet {
 public:
     ~DefaultWebBrowserApplet() override;
 
-    void OpenLocalWebPage(const std::string& local_url,
-                          std::function<void()> extract_romfs_callback,
-                          std::function<void(Service::AM::Applets::WebExitReason, std::string)>
-                              callback) const override;
+    void OpenLocalWebPage(const std::string& local_url, ExtractROMFSCallback extract_romfs_callback,
+                          OpenWebPageCallback callback) const override;
 
     void OpenExternalWebPage(const std::string& external_url,
-                             std::function<void(Service::AM::Applets::WebExitReason, std::string)>
-                                 callback) const override;
+                             OpenWebPageCallback callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/emu_window.h

@@ -131,6 +131,10 @@ public:
         return active_config;
     }
 
+    bool StrictContextRequired() const {
+        return strict_context_required;
+    }
+
     /**
      * Requests the internal configuration to be replaced by the specified argument at some point in
      * the future.
@@ -207,6 +211,8 @@ protected:
 
     WindowSystemInfo window_info;
 
+    bool strict_context_required = false;
+
 private:
     /**
      * Handler called when the minimal client area was requested to be changed via SetConfig.

src/core/hid/emulated_console.cpp

@@ -37,7 +37,7 @@ void EmulatedConsole::SetTouchParams() {
         touchscreen_param.Set("axis_x", i * 2);
         touchscreen_param.Set("axis_y", (i * 2) + 1);
         touchscreen_param.Set("button", i);
-        touch_params[index++] = touchscreen_param;
+        touch_params[index++] = std::move(touchscreen_param);
     }
 
     const auto button_index =
@@ -59,7 +59,7 @@ void EmulatedConsole::SetTouchParams() {
         touch_button_params.Set("button", params.Serialize());
         touch_button_params.Set("x", x);
         touch_button_params.Set("y", y);
-        touch_params[index] = touch_button_params;
+        touch_params[index] = std::move(touch_button_params);
         index++;
     }
 }
@@ -131,7 +131,7 @@ Common::ParamPackage EmulatedConsole::GetMotionParam() const {
 }
 
 void EmulatedConsole::SetMotionParam(Common::ParamPackage param) {
-    motion_params = param;
+    motion_params = std::move(param);
     ReloadInput();
 }
 
@@ -199,7 +199,7 @@ void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, st
 
     if (is_new_input) {
         touch_value.pressed.value = true;
-        touch_value.id = static_cast<u32>(index);
+        touch_value.id = static_cast<int>(index);
     }
 
     touch_value.x = touch_input.x;
@@ -284,7 +284,7 @@ void EmulatedConsole::TriggerOnChange(ConsoleTriggerType type) {
 
 int EmulatedConsole::SetCallback(ConsoleUpdateCallback update_callback) {
     std::scoped_lock lock{callback_mutex};
-    callback_list.insert_or_assign(last_callback_key, update_callback);
+    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
     return last_callback_key++;
 }
 

src/core/hid/emulated_controller.cpp

@@ -424,15 +424,14 @@ void EmulatedController::RestoreConfig() {
     ReloadFromSettings();
 }
 
-std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices(
-    EmulatedDeviceIndex device_index) const {
+std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices() const {
     std::vector<Common::ParamPackage> devices;
     for (const auto& param : button_params) {
         if (!param.Has("engine")) {
             continue;
         }
         const auto devices_it = std::find_if(
-            devices.begin(), devices.end(), [param](const Common::ParamPackage param_) {
+            devices.begin(), devices.end(), [&param](const Common::ParamPackage& param_) {
                 return param.Get("engine", "") == param_.Get("engine", "") &&
                        param.Get("guid", "") == param_.Get("guid", "") &&
                        param.Get("port", 0) == param_.Get("port", 0) &&
@@ -441,12 +440,12 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices(
         if (devices_it != devices.end()) {
             continue;
         }
-        Common::ParamPackage device{};
+
+        auto& device = devices.emplace_back();
         device.Set("engine", param.Get("engine", ""));
         device.Set("guid", param.Get("guid", ""));
         device.Set("port", param.Get("port", 0));
         device.Set("pad", param.Get("pad", 0));
-        devices.push_back(device);
     }
 
     for (const auto& param : stick_params) {
@@ -457,7 +456,7 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices(
             continue;
         }
         const auto devices_it = std::find_if(
-            devices.begin(), devices.end(), [param](const Common::ParamPackage param_) {
+            devices.begin(), devices.end(), [&param](const Common::ParamPackage& param_) {
                 return param.Get("engine", "") == param_.Get("engine", "") &&
                        param.Get("guid", "") == param_.Get("guid", "") &&
                        param.Get("port", 0) == param_.Get("port", 0) &&
@@ -466,12 +465,12 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices(
         if (devices_it != devices.end()) {
             continue;
         }
-        Common::ParamPackage device{};
+
+        auto& device = devices.emplace_back();
         device.Set("engine", param.Get("engine", ""));
         device.Set("guid", param.Get("guid", ""));
         device.Set("port", param.Get("port", 0));
         device.Set("pad", param.Get("pad", 0));
-        devices.push_back(device);
     }
     return devices;
 }

src/core/hid/emulated_controller.h

@@ -244,7 +244,7 @@ public:
     void RestoreConfig();
 
     /// Returns a vector of mapped devices from the mapped button and stick parameters
-    std::vector<Common::ParamPackage> GetMappedDevices(EmulatedDeviceIndex device_index) const;
+    std::vector<Common::ParamPackage> GetMappedDevices() const;
 
     // Returns the current mapped button device
     Common::ParamPackage GetButtonParam(std::size_t index) const;

src/core/hle/kernel/hle_ipc.cpp

@@ -318,25 +318,23 @@ Result HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_threa
 }
 
 std::vector<u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
-    std::vector<u8> buffer{};
     const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                            BufferDescriptorA()[buffer_index].Size()};
-
     if (is_buffer_a) {
         ASSERT_OR_EXECUTE_MSG(
-            BufferDescriptorA().size() > buffer_index, { return buffer; },
+            BufferDescriptorA().size() > buffer_index, { return {}; },
             "BufferDescriptorA invalid buffer_index {}", buffer_index);
-        buffer.resize(BufferDescriptorA()[buffer_index].Size());
+        std::vector<u8> buffer(BufferDescriptorA()[buffer_index].Size());
         memory.ReadBlock(BufferDescriptorA()[buffer_index].Address(), buffer.data(), buffer.size());
+        return buffer;
     } else {
         ASSERT_OR_EXECUTE_MSG(
-            BufferDescriptorX().size() > buffer_index, { return buffer; },
+            BufferDescriptorX().size() > buffer_index, { return {}; },
             "BufferDescriptorX invalid buffer_index {}", buffer_index);
-        buffer.resize(BufferDescriptorX()[buffer_index].Size());
+        std::vector<u8> buffer(BufferDescriptorX()[buffer_index].Size());
         memory.ReadBlock(BufferDescriptorX()[buffer_index].Address(), buffer.data(), buffer.size());
+        return buffer;
     }
-
-    return buffer;
 }
 
 std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,

src/core/hle/kernel/k_memory_block.h

@@ -280,18 +280,19 @@ struct KMemoryInfo {
 
 class KMemoryBlock : public Common::IntrusiveRedBlackTreeBaseNode<KMemoryBlock> {
 private:
-    u16 m_device_disable_merge_left_count;
-    u16 m_device_disable_merge_right_count;
-    VAddr m_address;
-    size_t m_num_pages;
-    KMemoryState m_memory_state;
-    u16 m_ipc_lock_count;
-    u16 m_device_use_count;
-    u16 m_ipc_disable_merge_count;
-    KMemoryPermission m_permission;
-    KMemoryPermission m_original_permission;
-    KMemoryAttribute m_attribute;
-    KMemoryBlockDisableMergeAttribute m_disable_merge_attribute;
+    u16 m_device_disable_merge_left_count{};
+    u16 m_device_disable_merge_right_count{};
+    VAddr m_address{};
+    size_t m_num_pages{};
+    KMemoryState m_memory_state{KMemoryState::None};
+    u16 m_ipc_lock_count{};
+    u16 m_device_use_count{};
+    u16 m_ipc_disable_merge_count{};
+    KMemoryPermission m_permission{KMemoryPermission::None};
+    KMemoryPermission m_original_permission{KMemoryPermission::None};
+    KMemoryAttribute m_attribute{KMemoryAttribute::None};
+    KMemoryBlockDisableMergeAttribute m_disable_merge_attribute{
+        KMemoryBlockDisableMergeAttribute::None};
 
 public:
     static constexpr int Compare(const KMemoryBlock& lhs, const KMemoryBlock& rhs) {
@@ -367,12 +368,8 @@ public:
 
     constexpr KMemoryBlock(VAddr addr, size_t np, KMemoryState ms, KMemoryPermission p,
                            KMemoryAttribute attr)
-        : Common::IntrusiveRedBlackTreeBaseNode<KMemoryBlock>(),
-          m_device_disable_merge_left_count(), m_device_disable_merge_right_count(),
-          m_address(addr), m_num_pages(np), m_memory_state(ms), m_ipc_lock_count(0),
-          m_device_use_count(0), m_ipc_disable_merge_count(), m_permission(p),
-          m_original_permission(KMemoryPermission::None), m_attribute(attr),
-          m_disable_merge_attribute() {}
+        : Common::IntrusiveRedBlackTreeBaseNode<KMemoryBlock>(), m_address(addr), m_num_pages(np),
+          m_memory_state(ms), m_permission(p), m_attribute(attr) {}
 
     constexpr void Initialize(VAddr addr, size_t np, KMemoryState ms, KMemoryPermission p,
                               KMemoryAttribute attr) {

src/core/hle/kernel/k_memory_block_manager.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <array>
 #include <functional>
 
 #include "common/common_funcs.h"
@@ -17,9 +18,9 @@ public:
     static constexpr size_t MaxBlocks = 2;
 
 private:
-    KMemoryBlock* m_blocks[MaxBlocks];
-    size_t m_index;
-    KMemoryBlockSlabManager* m_slab_manager;
+    std::array<KMemoryBlock*, MaxBlocks> m_blocks{};
+    size_t m_index{MaxBlocks};
+    KMemoryBlockSlabManager* m_slab_manager{};
 
 private:
     Result Initialize(size_t num_blocks) {
@@ -41,7 +42,7 @@ private:
 public:
     KMemoryBlockManagerUpdateAllocator(Result* out_result, KMemoryBlockSlabManager* sm,
                                        size_t num_blocks = MaxBlocks)
-        : m_blocks(), m_index(MaxBlocks), m_slab_manager(sm) {
+        : m_slab_manager(sm) {
         *out_result = this->Initialize(num_blocks);
     }
 

src/core/hle/kernel/k_shared_memory.h

@@ -74,7 +74,7 @@ public:
     static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
 
 private:
-    Core::DeviceMemory* device_memory;
+    Core::DeviceMemory* device_memory{};
     KProcess* owner_process{};
     KPageGroup page_list;
     Svc::MemoryPermission owner_permission{};

src/core/hle/kernel/k_thread.h

@@ -784,8 +784,8 @@ private:
     std::vector<KSynchronizationObject*> wait_objects_for_debugging;
     VAddr mutex_wait_address_for_debugging{};
     ThreadWaitReasonForDebugging wait_reason_for_debugging{};
-    uintptr_t argument;
-    VAddr stack_top;
+    uintptr_t argument{};
+    VAddr stack_top{};
 
 public:
     using ConditionVariableThreadTreeType = ConditionVariableThreadTree;

src/core/hle/kernel/kernel.cpp

@@ -104,12 +104,16 @@ struct KernelCore::Impl {
     }
 
     void CloseCurrentProcess() {
-        (*current_process).Finalize();
-        // current_process->Close();
-        // TODO: The current process should be destroyed based on accurate ref counting after
+        KProcess* old_process = current_process.exchange(nullptr);
+        if (old_process == nullptr) {
+            return;
+        }
+
+        // old_process->Close();
+        // TODO: The process should be destroyed based on accurate ref counting after
         // calling Close(). Adding a manual Destroy() call instead to avoid a memory leak.
-        (*current_process).Destroy();
-        current_process = nullptr;
+        old_process->Finalize();
+        old_process->Destroy();
     }
 
     void Shutdown() {
@@ -891,7 +895,7 @@ struct KernelCore::Impl {
     Common::ThreadWorker service_threads_manager;
     Common::Barrier service_thread_barrier;
 
-    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads;
+    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads{};
     std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
 
     bool is_multicore{};

src/core/hle/kernel/physical_core.h

@@ -85,7 +85,7 @@ private:
     std::mutex guard;
     std::condition_variable on_interrupt;
     std::unique_ptr<Core::ARM_Interface> arm_interface;
-    bool is_interrupted;
+    bool is_interrupted{};
 };
 
 } // namespace Kernel

src/core/hle/kernel/service_thread.cpp

@@ -163,9 +163,6 @@ ServiceThread::Impl::~Impl() {
     m_wakeup_event->Signal();
     m_host_thread.join();
 
-    // Lock mutex.
-    m_session_mutex.lock();
-
     // Close all remaining sessions.
     for (const auto& [server_session, manager] : m_sessions) {
         server_session->Close();

src/core/hle/service/audio/audin_u.cpp

@@ -203,8 +203,9 @@ private:
 };
 
 AudInU::AudInU(Core::System& system_)
-    : ServiceFramework{system_, "audin:u"}, service_context{system_, "AudInU"},
-      impl{std::make_unique<AudioCore::AudioIn::Manager>(system_)} {
+    : ServiceFramework{system_, "audin:u", ServiceThreadType::CreateNew},
+      service_context{system_, "AudInU"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
+                                              system_)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &AudInU::ListAudioIns, "ListAudioIns"},

src/core/hle/service/audio/audout_u.cpp

@@ -26,8 +26,9 @@ public:
     explicit IAudioOut(Core::System& system_, AudioCore::AudioOut::Manager& manager,
                        size_t session_id, const std::string& device_name,
                        const AudioOutParameter& in_params, u32 handle, u64 applet_resource_user_id)
-        : ServiceFramework{system_, "IAudioOut"}, service_context{system_, "IAudioOut"},
-          event{service_context.CreateEvent("AudioOutEvent")},
+        : ServiceFramework{system_, "IAudioOut", ServiceThreadType::CreateNew},
+          service_context{system_, "IAudioOut"}, event{service_context.CreateEvent(
+                                                     "AudioOutEvent")},
           impl{std::make_shared<AudioCore::AudioOut::Out>(system_, manager, event, session_id)} {
 
         // clang-format off
@@ -220,8 +221,9 @@ private:
 };
 
 AudOutU::AudOutU(Core::System& system_)
-    : ServiceFramework{system_, "audout:u"}, service_context{system_, "AudOutU"},
-      impl{std::make_unique<AudioCore::AudioOut::Manager>(system_)} {
+    : ServiceFramework{system_, "audout:u", ServiceThreadType::CreateNew},
+      service_context{system_, "AudOutU"}, impl{std::make_unique<AudioCore::AudioOut::Manager>(
+                                               system_)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &AudOutU::ListAudioOuts, "ListAudioOuts"},

src/core/hle/service/audio/audren_u.cpp

@@ -35,9 +35,10 @@ public:
                             AudioCore::AudioRendererParameterInternal& params,
                             Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
                             u32 process_handle, u64 applet_resource_user_id, s32 session_id)
-        : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
-          rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
-          impl{std::make_unique<Renderer>(system_, manager, rendered_event)} {
+        : ServiceFramework{system_, "IAudioRenderer", ServiceThreadType::CreateNew},
+          service_context{system_, "IAudioRenderer"}, rendered_event{service_context.CreateEvent(
+                                                          "IAudioRendererEvent")},
+          manager{manager_}, impl{std::make_unique<Renderer>(system_, manager, rendered_event)} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IAudioRenderer::GetSampleRate, "GetSampleRate"},
@@ -242,8 +243,10 @@ class IAudioDevice final : public ServiceFramework<IAudioDevice> {
 public:
     explicit IAudioDevice(Core::System& system_, u64 applet_resource_user_id, u32 revision,
                           u32 device_num)
-        : ServiceFramework{system_, "IAudioDevice"}, service_context{system_, "IAudioDevice"},
-          impl{std::make_unique<AudioDevice>(system_, applet_resource_user_id, revision)},
+        : ServiceFramework{system_, "IAudioDevice", ServiceThreadType::CreateNew},
+          service_context{system_, "IAudioDevice"}, impl{std::make_unique<AudioDevice>(
+                                                        system_, applet_resource_user_id,
+                                                        revision)},
           event{service_context.CreateEvent(fmt::format("IAudioDeviceEvent-{}", device_num))} {
         static const FunctionInfo functions[] = {
             {0, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceName"},
@@ -418,7 +421,7 @@ private:
 };
 
 AudRenU::AudRenU(Core::System& system_)
-    : ServiceFramework{system_, "audren:u"},
+    : ServiceFramework{system_, "audren:u", ServiceThreadType::CreateNew},
       service_context{system_, "audren:u"}, impl{std::make_unique<Manager>(system_)} {
     // clang-format off
     static const FunctionInfo functions[] = {

src/core/hle/service/nfc/mifare_user.cpp

@@ -0,0 +1,400 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/hid/hid_types.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/nfc/mifare_user.h"
+#include "core/hle/service/nfc/nfc_device.h"
+#include "core/hle/service/nfc/nfc_result.h"
+
+namespace Service::NFC {
+
+MFIUser::MFIUser(Core::System& system_)
+    : ServiceFramework{system_, "NFC::MFIUser"}, service_context{system_, service_name} {
+    static const FunctionInfo functions[] = {
+        {0, &MFIUser::Initialize, "Initialize"},
+        {1, &MFIUser::Finalize, "Finalize"},
+        {2, &MFIUser::ListDevices, "ListDevices"},
+        {3, &MFIUser::StartDetection, "StartDetection"},
+        {4, &MFIUser::StopDetection, "StopDetection"},
+        {5, &MFIUser::Read, "Read"},
+        {6, &MFIUser::Write, "Write"},
+        {7, &MFIUser::GetTagInfo, "GetTagInfo"},
+        {8, &MFIUser::GetActivateEventHandle, "GetActivateEventHandle"},
+        {9, &MFIUser::GetDeactivateEventHandle, "GetDeactivateEventHandle"},
+        {10, &MFIUser::GetState, "GetState"},
+        {11, &MFIUser::GetDeviceState, "GetDeviceState"},
+        {12, &MFIUser::GetNpadId, "GetNpadId"},
+        {13, &MFIUser::GetAvailabilityChangeEventHandle, "GetAvailabilityChangeEventHandle"},
+    };
+    RegisterHandlers(functions);
+
+    availability_change_event = service_context.CreateEvent("MFIUser:AvailabilityChangeEvent");
+
+    for (u32 device_index = 0; device_index < 10; device_index++) {
+        devices[device_index] =
+            std::make_shared<NfcDevice>(Core::HID::IndexToNpadIdType(device_index), system,
+                                        service_context, availability_change_event);
+    }
+}
+
+MFIUser ::~MFIUser() {
+    availability_change_event->Close();
+}
+
+void MFIUser::Initialize(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFC, "called");
+
+    state = State::Initialized;
+
+    for (auto& device : devices) {
+        device->Initialize();
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 0};
+    rb.Push(ResultSuccess);
+}
+
+void MFIUser::Finalize(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFC, "called");
+
+    state = State::NonInitialized;
+
+    for (auto& device : devices) {
+        device->Finalize();
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void MFIUser::ListDevices(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_NFC, "called");
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    if (!ctx.CanWriteBuffer()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareInvalidArgument);
+        return;
+    }
+
+    if (ctx.GetWriteBufferSize() == 0) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareInvalidArgument);
+        return;
+    }
+
+    std::vector<u64> nfp_devices;
+    const std::size_t max_allowed_devices = ctx.GetWriteBufferNumElements<u64>();
+
+    for (const auto& device : devices) {
+        if (nfp_devices.size() >= max_allowed_devices) {
+            continue;
+        }
+        if (device->GetCurrentState() != NFP::DeviceState::Unavailable) {
+            nfp_devices.push_back(device->GetHandle());
+        }
+    }
+
+    if (nfp_devices.empty()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    ctx.WriteBuffer(nfp_devices);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(static_cast<s32>(nfp_devices.size()));
+}
+
+void MFIUser::StartDetection(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    const auto result = device.value()->StartDetection(NFP::TagProtocol::All);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::StopDetection(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    const auto result = device.value()->StopDetection();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::Read(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto buffer{ctx.ReadBuffer()};
+    const auto number_of_commands{ctx.GetReadBufferNumElements<NFP::MifareReadBlockParameter>()};
+    std::vector<NFP::MifareReadBlockParameter> read_commands(number_of_commands);
+
+    memcpy(read_commands.data(), buffer.data(),
+           number_of_commands * sizeof(NFP::MifareReadBlockParameter));
+
+    LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, read_commands_size={}",
+             device_handle, number_of_commands);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    Result result = ResultSuccess;
+    std::vector<NFP::MifareReadBlockData> out_data(number_of_commands);
+    for (std::size_t i = 0; i < number_of_commands; i++) {
+        result = device.value()->MifareRead(read_commands[i], out_data[i]);
+        if (result.IsError()) {
+            break;
+        }
+    }
+
+    ctx.WriteBuffer(out_data);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::Write(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto buffer{ctx.ReadBuffer()};
+    const auto number_of_commands{ctx.GetReadBufferNumElements<NFP::MifareWriteBlockParameter>()};
+    std::vector<NFP::MifareWriteBlockParameter> write_commands(number_of_commands);
+
+    memcpy(write_commands.data(), buffer.data(),
+           number_of_commands * sizeof(NFP::MifareWriteBlockParameter));
+
+    LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, write_commands_size={}",
+             device_handle, number_of_commands);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    Result result = ResultSuccess;
+    std::vector<NFP::MifareReadBlockData> out_data(number_of_commands);
+    for (std::size_t i = 0; i < number_of_commands; i++) {
+        result = device.value()->MifareWrite(write_commands[i]);
+        if (result.IsError()) {
+            break;
+        }
+    }
+
+    if (result.IsSuccess()) {
+        result = device.value()->Flush();
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::GetTagInfo(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    NFP::TagInfo tag_info{};
+    const auto result = device.value()->GetTagInfo(tag_info, true);
+    ctx.WriteBuffer(tag_info);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::GetActivateEventHandle(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(device.value()->GetActivateEvent());
+}
+
+void MFIUser::GetDeactivateEventHandle(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(device.value()->GetDeactivateEvent());
+}
+
+void MFIUser::GetState(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_NFC, "called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(state);
+}
+
+void MFIUser::GetDeviceState(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(device.value()->GetCurrentState());
+}
+
+void MFIUser::GetNpadId(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(device.value()->GetNpadId());
+}
+
+void MFIUser::GetAvailabilityChangeEventHandle(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFC, "called");
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(availability_change_event->GetReadableEvent());
+}
+
+std::optional<std::shared_ptr<NfcDevice>> MFIUser::GetNfcDevice(u64 handle) {
+    for (auto& device : devices) {
+        if (device->GetHandle() == handle) {
+            return device;
+        }
+    }
+    return std::nullopt;
+}
+
+} // namespace Service::NFC

src/core/hle/service/nfc/mifare_user.h

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <optional>
+
+#include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/service.h"
+
+namespace Service::NFC {
+class NfcDevice;
+
+class MFIUser final : public ServiceFramework<MFIUser> {
+public:
+    explicit MFIUser(Core::System& system_);
+    ~MFIUser();
+
+private:
+    enum class State : u32 {
+        NonInitialized,
+        Initialized,
+    };
+
+    void Initialize(Kernel::HLERequestContext& ctx);
+    void Finalize(Kernel::HLERequestContext& ctx);
+    void ListDevices(Kernel::HLERequestContext& ctx);
+    void StartDetection(Kernel::HLERequestContext& ctx);
+    void StopDetection(Kernel::HLERequestContext& ctx);
+    void Read(Kernel::HLERequestContext& ctx);
+    void Write(Kernel::HLERequestContext& ctx);
+    void GetTagInfo(Kernel::HLERequestContext& ctx);
+    void GetActivateEventHandle(Kernel::HLERequestContext& ctx);
+    void GetDeactivateEventHandle(Kernel::HLERequestContext& ctx);
+    void GetState(Kernel::HLERequestContext& ctx);
+    void GetDeviceState(Kernel::HLERequestContext& ctx);
+    void GetNpadId(Kernel::HLERequestContext& ctx);
+    void GetAvailabilityChangeEventHandle(Kernel::HLERequestContext& ctx);
+
+    std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle);
+
+    KernelHelpers::ServiceContext service_context;
+
+    std::array<std::shared_ptr<NfcDevice>, 10> devices{};
+
+    State state{State::NonInitialized};
+    Kernel::KEvent* availability_change_event;
+};
+
+} // namespace Service::NFC

src/core/hle/service/nfc/nfc.cpp

@@ -6,6 +6,7 @@
 #include "common/logging/log.h"
 #include "common/settings.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/service/nfc/mifare_user.h"
 #include "core/hle/service/nfc/nfc.h"
 #include "core/hle/service/nfc/nfc_user.h"
 #include "core/hle/service/service.h"
@@ -50,32 +51,6 @@ private:
     }
 };
 
-class MFIUser final : public ServiceFramework<MFIUser> {
-public:
-    explicit MFIUser(Core::System& system_) : ServiceFramework{system_, "NFC::MFIUser"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Initialize"},
-            {1, nullptr, "Finalize"},
-            {2, nullptr, "ListDevices"},
-            {3, nullptr, "StartDetection"},
-            {4, nullptr, "StopDetection"},
-            {5, nullptr, "Read"},
-            {6, nullptr, "Write"},
-            {7, nullptr, "GetTagInfo"},
-            {8, nullptr, "GetActivateEventHandle"},
-            {9, nullptr, "GetDeactivateEventHandle"},
-            {10, nullptr, "GetState"},
-            {11, nullptr, "GetDeviceState"},
-            {12, nullptr, "GetNpadId"},
-            {13, nullptr, "GetAvailabilityChangeEventHandle"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
 class NFC_MF_U final : public ServiceFramework<NFC_MF_U> {
 public:
     explicit NFC_MF_U(Core::System& system_) : ServiceFramework{system_, "nfc:mf:u"} {

src/core/hle/service/nfc/nfc_device.cpp

@@ -77,11 +77,13 @@ bool NfcDevice::LoadNfcTag(std::span<const u8> data) {
         return false;
     }
 
-    if (data.size() != sizeof(NFP::EncryptedNTAG215File)) {
+    if (data.size() < sizeof(NFP::EncryptedNTAG215File)) {
         LOG_ERROR(Service_NFC, "Not an amiibo, size={}", data.size());
         return false;
     }
 
+    tag_data.resize(data.size());
+    memcpy(tag_data.data(), data.data(), data.size());
     memcpy(&encrypted_tag_data, data.data(), sizeof(NFP::EncryptedNTAG215File));
 
     device_state = NFP::DeviceState::TagFound;
@@ -121,7 +123,7 @@ void NfcDevice::Finalize() {
     device_state = NFP::DeviceState::Unavailable;
 }
 
-Result NfcDevice::StartDetection(s32 protocol_) {
+Result NfcDevice::StartDetection(NFP::TagProtocol allowed_protocol) {
     if (device_state != NFP::DeviceState::Initialized &&
         device_state != NFP::DeviceState::TagRemoved) {
         LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
@@ -134,7 +136,7 @@ Result NfcDevice::StartDetection(s32 protocol_) {
     }
 
     device_state = NFP::DeviceState::SearchingForTag;
-    protocol = protocol_;
+    allowed_protocols = allowed_protocol;
     return ResultSuccess;
 }
 
@@ -160,7 +162,7 @@ Result NfcDevice::StopDetection() {
     return WrongDeviceState;
 }
 
-Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info) const {
+Result NfcDevice::Flush() {
     if (device_state != NFP::DeviceState::TagFound &&
         device_state != NFP::DeviceState::TagMounted) {
         LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
@@ -170,6 +172,34 @@ Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info) const {
         return WrongDeviceState;
     }
 
+    if (!npad_device->WriteNfc(tag_data)) {
+        LOG_ERROR(Service_NFP, "Error writing to file");
+        return MifareReadError;
+    }
+
+    return ResultSuccess;
+}
+
+Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info, bool is_mifare) const {
+    if (device_state != NFP::DeviceState::TagFound &&
+        device_state != NFP::DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
+        if (device_state == NFP::DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+
+    if (is_mifare) {
+        tag_info = {
+            .uuid = encrypted_tag_data.uuid.uid,
+            .uuid_length = static_cast<u8>(encrypted_tag_data.uuid.uid.size()),
+            .protocol = NFP::TagProtocol::TypeA,
+            .tag_type = NFP::TagType::Type4,
+        };
+        return ResultSuccess;
+    }
+
     // Protocol and tag type may change here
     tag_info = {
         .uuid = encrypted_tag_data.uuid.uid,
@@ -181,6 +211,52 @@ Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info) const {
     return ResultSuccess;
 }
 
+Result NfcDevice::MifareRead(const NFP::MifareReadBlockParameter& parameter,
+                             NFP::MifareReadBlockData& read_block_data) {
+    const std::size_t sector_index = parameter.sector_number * sizeof(NFP::DataBlock);
+    read_block_data.sector_number = parameter.sector_number;
+
+    if (device_state != NFP::DeviceState::TagFound &&
+        device_state != NFP::DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
+        if (device_state == NFP::DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+
+    if (tag_data.size() < sector_index + sizeof(NFP::DataBlock)) {
+        return MifareReadError;
+    }
+
+    // TODO: Use parameter.sector_key to read encrypted data
+    memcpy(read_block_data.data.data(), tag_data.data() + sector_index, sizeof(NFP::DataBlock));
+
+    return ResultSuccess;
+}
+
+Result NfcDevice::MifareWrite(const NFP::MifareWriteBlockParameter& parameter) {
+    const std::size_t sector_index = parameter.sector_number * sizeof(NFP::DataBlock);
+
+    if (device_state != NFP::DeviceState::TagFound &&
+        device_state != NFP::DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
+        if (device_state == NFP::DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+
+    if (tag_data.size() < sector_index + sizeof(NFP::DataBlock)) {
+        return MifareReadError;
+    }
+
+    // TODO: Use parameter.sector_key to encrypt the data
+    memcpy(tag_data.data() + sector_index, parameter.data.data(), sizeof(NFP::DataBlock));
+
+    return ResultSuccess;
+}
+
 u64 NfcDevice::GetHandle() const {
     // Generate a handle based of the npad id
     return static_cast<u64>(npad_id);

src/core/hle/service/nfc/nfc_device.h

@@ -34,10 +34,16 @@ public:
     void Initialize();
     void Finalize();
 
-    Result StartDetection(s32 protocol_);
+    Result StartDetection(NFP::TagProtocol allowed_protocol);
     Result StopDetection();
+    Result Flush();
 
-    Result GetTagInfo(NFP::TagInfo& tag_info) const;
+    Result GetTagInfo(NFP::TagInfo& tag_info, bool is_mifare) const;
+
+    Result MifareRead(const NFP::MifareReadBlockParameter& parameter,
+                      NFP::MifareReadBlockData& read_block_data);
+
+    Result MifareWrite(const NFP::MifareWriteBlockParameter& parameter);
 
     u64 GetHandle() const;
     NFP::DeviceState GetCurrentState() const;
@@ -61,10 +67,11 @@ private:
     Kernel::KEvent* deactivate_event = nullptr;
     Kernel::KEvent* availability_change_event = nullptr;
 
-    s32 protocol{};
+    NFP::TagProtocol allowed_protocols{};
     NFP::DeviceState device_state{NFP::DeviceState::Unavailable};
 
     NFP::EncryptedNTAG215File encrypted_tag_data{};
+    std::vector<u8> tag_data{};
 };
 
 } // namespace Service::NFC

src/core/hle/service/nfc/nfc_result.h

@@ -12,6 +12,12 @@ constexpr Result InvalidArgument(ErrorModule::NFC, 65);
 constexpr Result WrongDeviceState(ErrorModule::NFC, 73);
 constexpr Result NfcDisabled(ErrorModule::NFC, 80);
 constexpr Result TagRemoved(ErrorModule::NFC, 97);
-constexpr Result CorruptedData(ErrorModule::NFC, 144);
+
+constexpr Result MifareDeviceNotFound(ErrorModule::NFCMifare, 64);
+constexpr Result MifareInvalidArgument(ErrorModule::NFCMifare, 65);
+constexpr Result MifareWrongDeviceState(ErrorModule::NFCMifare, 73);
+constexpr Result MifareNfcDisabled(ErrorModule::NFCMifare, 80);
+constexpr Result MifareTagRemoved(ErrorModule::NFCMifare, 97);
+constexpr Result MifareReadError(ErrorModule::NFCMifare, 288);
 
 } // namespace Service::NFC

src/core/hle/service/nfc/nfc_user.cpp

@@ -201,7 +201,7 @@ void IUser::AttachAvailabilityChangeEvent(Kernel::HLERequestContext& ctx) {
 void IUser::StartDetection(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto device_handle{rp.Pop<u64>()};
-    const auto nfp_protocol{rp.Pop<s32>()};
+    const auto nfp_protocol{rp.PopEnum<NFP::TagProtocol>()};
     LOG_INFO(Service_NFC, "called, device_handle={}, nfp_protocol={}", device_handle, nfp_protocol);
 
     if (state == State::NonInitialized) {
@@ -267,7 +267,7 @@ void IUser::GetTagInfo(Kernel::HLERequestContext& ctx) {
     }
 
     NFP::TagInfo tag_info{};
-    const auto result = device.value()->GetTagInfo(tag_info);
+    const auto result = device.value()->GetTagInfo(tag_info, false);
     ctx.WriteBuffer(tag_info);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(result);

src/core/hle/service/nfp/nfp_types.h

@@ -106,11 +106,24 @@ enum class CabinetMode : u8 {
     StartFormatter,
 };
 
+enum class MifareCmd : u8 {
+    AuthA = 0x60,
+    AuthB = 0x61,
+    Read = 0x30,
+    Write = 0xA0,
+    Transfer = 0xB0,
+    Decrement = 0xC0,
+    Increment = 0xC1,
+    Store = 0xC2
+};
+
 using UniqueSerialNumber = std::array<u8, 7>;
 using LockBytes = std::array<u8, 2>;
 using HashData = std::array<u8, 0x20>;
 using ApplicationArea = std::array<u8, 0xD8>;
 using AmiiboName = std::array<char, (amiibo_name_length * 4) + 1>;
+using DataBlock = std::array<u8, 0x10>;
+using KeyData = std::array<u8, 0x6>;
 
 struct TagUuid {
     UniqueSerialNumber uid;
@@ -323,4 +336,37 @@ struct RegisterInfo {
 };
 static_assert(sizeof(RegisterInfo) == 0x100, "RegisterInfo is an invalid size");
 
+struct SectorKey {
+    MifareCmd command;
+    u8 unknown; // Usually 1
+    INSERT_PADDING_BYTES(0x6);
+    KeyData sector_key;
+    INSERT_PADDING_BYTES(0x2);
+};
+static_assert(sizeof(SectorKey) == 0x10, "SectorKey is an invalid size");
+
+struct MifareReadBlockParameter {
+    u8 sector_number;
+    INSERT_PADDING_BYTES(0x7);
+    SectorKey sector_key;
+};
+static_assert(sizeof(MifareReadBlockParameter) == 0x18,
+              "MifareReadBlockParameter is an invalid size");
+
+struct MifareReadBlockData {
+    DataBlock data;
+    u8 sector_number;
+    INSERT_PADDING_BYTES(0x7);
+};
+static_assert(sizeof(MifareReadBlockData) == 0x18, "MifareReadBlockData is an invalid size");
+
+struct MifareWriteBlockParameter {
+    DataBlock data;
+    u8 sector_number;
+    INSERT_PADDING_BYTES(0x7);
+    SectorKey sector_key;
+};
+static_assert(sizeof(MifareWriteBlockParameter) == 0x28,
+              "MifareWriteBlockParameter is an invalid size");
+
 } // namespace Service::NFP

src/core/memory.cpp

@@ -6,7 +6,6 @@
 
 #include "common/assert.h"
 #include "common/atomic_ops.h"
-#include "common/cache_management.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
@@ -195,13 +194,11 @@ struct Memory::Impl {
                 break;
             }
             case Common::PageType::Memory: {
-                DEBUG_ASSERT(pointer);
                 u8* mem_ptr = pointer + page_offset + (page_index << YUZU_PAGEBITS);
                 on_memory(copy_amount, mem_ptr);
                 break;
             }
             case Common::PageType::DebugMemory: {
-                DEBUG_ASSERT(pointer);
                 u8* const mem_ptr{GetPointerFromDebugMemory(current_vaddr)};
                 on_memory(copy_amount, mem_ptr);
                 break;
@@ -342,10 +339,9 @@ struct Memory::Impl {
                     LOG_ERROR(HW_Memory, "Unmapped cache maintenance @ {:#018X}", current_vaddr);
                     throw InvalidMemoryException();
                 },
-                [&](const std::size_t block_size, u8* const host_ptr) { cb(block_size, host_ptr); },
+                [&](const std::size_t block_size, u8* const host_ptr) {},
                 [&](const VAddr current_vaddr, const std::size_t block_size, u8* const host_ptr) {
-                    system.GPU().FlushRegion(current_vaddr, block_size);
-                    cb(block_size, host_ptr);
+                    cb(current_vaddr, block_size);
                 },
                 [](const std::size_t block_size) {});
         } catch (InvalidMemoryException&) {
@@ -356,27 +352,30 @@ struct Memory::Impl {
     }
 
     Result InvalidateDataCache(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size) {
-        auto perform = [&](const std::size_t block_size, u8* const host_ptr) {
-            // Do nothing; this operation (dc ivac) cannot be supported
-            // from EL0
+        auto on_rasterizer = [&](const VAddr current_vaddr, const std::size_t block_size) {
+            // dc ivac: Invalidate to point of coherency
+            // GPU flush -> CPU invalidate
+            system.GPU().FlushRegion(current_vaddr, block_size);
         };
-        return PerformCacheOperation(process, dest_addr, size, perform);
+        return PerformCacheOperation(process, dest_addr, size, on_rasterizer);
     }
 
     Result StoreDataCache(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size) {
-        auto perform = [&](const std::size_t block_size, u8* const host_ptr) {
+        auto on_rasterizer = [&](const VAddr current_vaddr, const std::size_t block_size) {
             // dc cvac: Store to point of coherency
-            Common::DataCacheLineCleanByVAToPoC(host_ptr, block_size);
+            // CPU flush -> GPU invalidate
+            system.GPU().InvalidateRegion(current_vaddr, block_size);
         };
-        return PerformCacheOperation(process, dest_addr, size, perform);
+        return PerformCacheOperation(process, dest_addr, size, on_rasterizer);
     }
 
     Result FlushDataCache(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size) {
-        auto perform = [&](const std::size_t block_size, u8* const host_ptr) {
+        auto on_rasterizer = [&](const VAddr current_vaddr, const std::size_t block_size) {
             // dc civac: Store to point of coherency, and invalidate from cache
-            Common::DataCacheLineCleanAndInvalidateByVAToPoC(host_ptr, block_size);
+            // CPU flush -> GPU invalidate
+            system.GPU().InvalidateRegion(current_vaddr, block_size);
         };
-        return PerformCacheOperation(process, dest_addr, size, perform);
+        return PerformCacheOperation(process, dest_addr, size, on_rasterizer);
     }
 
     void MarkRegionDebug(VAddr vaddr, u64 size, bool debug) {

src/core/reporter.cpp

@@ -38,7 +38,7 @@ std::string GetTimestamp() {
 
 using namespace nlohmann;
 
-void SaveToFile(json json, const std::filesystem::path& filename) {
+void SaveToFile(const json& json, const std::filesystem::path& filename) {
     if (!Common::FS::CreateParentDirs(filename)) {
         LOG_ERROR(Core, "Failed to create path for '{}' to save report!",
                   Common::FS::PathToUTF8String(filename));
@@ -81,8 +81,8 @@ json GetReportCommonData(u64 title_id, Result result, const std::string& timesta
 }
 
 json GetProcessorStateData(const std::string& architecture, u64 entry_point, u64 sp, u64 pc,
-                           u64 pstate, std::array<u64, 31> registers,
-                           std::optional<std::array<u64, 32>> backtrace = {}) {
+                           u64 pstate, const std::array<u64, 31>& registers,
+                           const std::optional<std::array<u64, 32>>& backtrace = {}) {
     auto out = json{
         {"entry_point", fmt::format("{:016X}", entry_point)},
         {"sp", fmt::format("{:016X}", sp)},
@@ -224,11 +224,11 @@ void Reporter::SaveCrashReport(u64 title_id, Result result, u64 set_flags, u64 e
 
     out["processor_state"] = std::move(proc_out);
 
-    SaveToFile(std::move(out), GetPath("crash_report", title_id, timestamp));
+    SaveToFile(out, GetPath("crash_report", title_id, timestamp));
 }
 
 void Reporter::SaveSvcBreakReport(u32 type, bool signal_debugger, u64 info1, u64 info2,
-                                  std::optional<std::vector<u8>> resolved_buffer) const {
+                                  const std::optional<std::vector<u8>>& resolved_buffer) const {
     if (!IsReportingEnabled()) {
         return;
     }
@@ -250,7 +250,7 @@ void Reporter::SaveSvcBreakReport(u32 type, bool signal_debugger, u64 info1, u64
 
     out["svc_break"] = std::move(break_out);
 
-    SaveToFile(std::move(out), GetPath("svc_break_report", title_id, timestamp));
+    SaveToFile(out, GetPath("svc_break_report", title_id, timestamp));
 }
 
 void Reporter::SaveUnimplementedFunctionReport(Kernel::HLERequestContext& ctx, u32 command_id,
@@ -271,13 +271,13 @@ void Reporter::SaveUnimplementedFunctionReport(Kernel::HLERequestContext& ctx, u
 
     out["function"] = std::move(function_out);
 
-    SaveToFile(std::move(out), GetPath("unimpl_func_report", title_id, timestamp));
+    SaveToFile(out, GetPath("unimpl_func_report", title_id, timestamp));
 }
 
 void Reporter::SaveUnimplementedAppletReport(
     u32 applet_id, u32 common_args_version, u32 library_version, u32 theme_color,
-    bool startup_sound, u64 system_tick, std::vector<std::vector<u8>> normal_channel,
-    std::vector<std::vector<u8>> interactive_channel) const {
+    bool startup_sound, u64 system_tick, const std::vector<std::vector<u8>>& normal_channel,
+    const std::vector<std::vector<u8>>& interactive_channel) const {
     if (!IsReportingEnabled()) {
         return;
     }
@@ -308,10 +308,11 @@ void Reporter::SaveUnimplementedAppletReport(
     out["applet_normal_data"] = std::move(normal_out);
     out["applet_interactive_data"] = std::move(interactive_out);
 
-    SaveToFile(std::move(out), GetPath("unimpl_applet_report", title_id, timestamp));
+    SaveToFile(out, GetPath("unimpl_applet_report", title_id, timestamp));
 }
 
-void Reporter::SavePlayReport(PlayReportType type, u64 title_id, std::vector<std::vector<u8>> data,
+void Reporter::SavePlayReport(PlayReportType type, u64 title_id,
+                              const std::vector<std::vector<u8>>& data,
                               std::optional<u64> process_id, std::optional<u128> user_id) const {
     if (!IsReportingEnabled()) {
         return;
@@ -335,12 +336,12 @@ void Reporter::SavePlayReport(PlayReportType type, u64 title_id, std::vector<std
     out["play_report_type"] = fmt::format("{:02}", static_cast<u8>(type));
     out["play_report_data"] = std::move(data_out);
 
-    SaveToFile(std::move(out), GetPath("play_report", title_id, timestamp));
+    SaveToFile(out, GetPath("play_report", title_id, timestamp));
 }
 
 void Reporter::SaveErrorReport(u64 title_id, Result result,
-                               std::optional<std::string> custom_text_main,
-                               std::optional<std::string> custom_text_detail) const {
+                               const std::optional<std::string>& custom_text_main,
+                               const std::optional<std::string>& custom_text_detail) const {
     if (!IsReportingEnabled()) {
         return;
     }
@@ -354,11 +355,11 @@ void Reporter::SaveErrorReport(u64 title_id, Result result,
     out["backtrace"] = GetBacktraceData(system);
 
     out["error_custom_text"] = {
-        {"main", *custom_text_main},
-        {"detail", *custom_text_detail},
+        {"main", custom_text_main.value_or("")},
+        {"detail", custom_text_detail.value_or("")},
     };
 
-    SaveToFile(std::move(out), GetPath("error_report", title_id, timestamp));
+    SaveToFile(out, GetPath("error_report", title_id, timestamp));
 }
 
 void Reporter::SaveFSAccessLog(std::string_view log_message) const {

src/core/reporter.h

@@ -36,7 +36,7 @@ public:
 
     // Used by syscall svcBreak
     void SaveSvcBreakReport(u32 type, bool signal_debugger, u64 info1, u64 info2,
-                            std::optional<std::vector<u8>> resolved_buffer = {}) const;
+                            const std::optional<std::vector<u8>>& resolved_buffer = {}) const;
 
     // Used by HLE service handler
     void SaveUnimplementedFunctionReport(Kernel::HLERequestContext& ctx, u32 command_id,
@@ -44,10 +44,10 @@ public:
                                          const std::string& service_name) const;
 
     // Used by stub applet implementation
-    void SaveUnimplementedAppletReport(u32 applet_id, u32 common_args_version, u32 library_version,
-                                       u32 theme_color, bool startup_sound, u64 system_tick,
-                                       std::vector<std::vector<u8>> normal_channel,
-                                       std::vector<std::vector<u8>> interactive_channel) const;
+    void SaveUnimplementedAppletReport(
+        u32 applet_id, u32 common_args_version, u32 library_version, u32 theme_color,
+        bool startup_sound, u64 system_tick, const std::vector<std::vector<u8>>& normal_channel,
+        const std::vector<std::vector<u8>>& interactive_channel) const;
 
     enum class PlayReportType {
         Old,
@@ -56,13 +56,13 @@ public:
         System,
     };
 
-    void SavePlayReport(PlayReportType type, u64 title_id, std::vector<std::vector<u8>> data,
+    void SavePlayReport(PlayReportType type, u64 title_id, const std::vector<std::vector<u8>>& data,
                         std::optional<u64> process_id = {}, std::optional<u128> user_id = {}) const;
 
     // Used by error applet
     void SaveErrorReport(u64 title_id, Result result,
-                         std::optional<std::string> custom_text_main = {},
-                         std::optional<std::string> custom_text_detail = {}) const;
+                         const std::optional<std::string>& custom_text_main = {},
+                         const std::optional<std::string>& custom_text_detail = {}) const;
 
     void SaveFSAccessLog(std::string_view log_message) const;
 

src/input_common/CMakeLists.txt

@@ -56,18 +56,12 @@ if (ENABLE_SDL2)
         drivers/sdl_driver.cpp
         drivers/sdl_driver.h
     )
-    if (YUZU_USE_EXTERNAL_SDL2)
-        target_link_libraries(input_common PRIVATE SDL2-static)
-    else()
-        target_link_libraries(input_common PRIVATE SDL2)
-    endif()
+    target_link_libraries(input_common PRIVATE SDL2::SDL2)
     target_compile_definitions(input_common PRIVATE HAVE_SDL2)
 endif()
 
-target_link_libraries(input_common PRIVATE usb)
-
 create_target_directory_groups(input_common)
-target_link_libraries(input_common PUBLIC core PRIVATE common Boost::boost)
+target_link_libraries(input_common PUBLIC core PRIVATE common Boost::boost libusb::usb)
 
 if (YUZU_USE_PRECOMPILED_HEADERS)
     target_precompile_headers(input_common PRIVATE precompiled_headers.h)

src/input_common/drivers/sdl_driver.cpp

@@ -16,6 +16,8 @@ Common::UUID GetGUID(SDL_Joystick* joystick) {
     const SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
     std::array<u8, 16> data{};
     std::memcpy(data.data(), guid.data, sizeof(data));
+    // Clear controller name crc
+    std::memset(data.data() + 2, 0, sizeof(u16));
     return Common::UUID{data};
 }
 } // Anonymous namespace

src/input_common/drivers/virtual_amiibo.cpp

@@ -47,20 +47,20 @@ Common::Input::NfcState VirtualAmiibo::SupportsNfc(
 
 Common::Input::NfcState VirtualAmiibo::WriteNfcData(
     [[maybe_unused]] const PadIdentifier& identifier_, const std::vector<u8>& data) {
-    const Common::FS::IOFile amiibo_file{file_path, Common::FS::FileAccessMode::ReadWrite,
-                                         Common::FS::FileType::BinaryFile};
+    const Common::FS::IOFile nfc_file{file_path, Common::FS::FileAccessMode::ReadWrite,
+                                      Common::FS::FileType::BinaryFile};
 
-    if (!amiibo_file.IsOpen()) {
+    if (!nfc_file.IsOpen()) {
         LOG_ERROR(Core, "Amiibo is already on use");
         return Common::Input::NfcState::WriteFailed;
     }
 
-    if (!amiibo_file.Write(data)) {
+    if (!nfc_file.Write(data)) {
         LOG_ERROR(Service_NFP, "Error writting to file");
         return Common::Input::NfcState::WriteFailed;
     }
 
-    amiibo_data = data;
+    nfc_data = data;
 
     return Common::Input::NfcState::Success;
 }
@@ -70,32 +70,44 @@ VirtualAmiibo::State VirtualAmiibo::GetCurrentState() const {
 }
 
 VirtualAmiibo::Info VirtualAmiibo::LoadAmiibo(const std::string& filename) {
-    const Common::FS::IOFile amiibo_file{filename, Common::FS::FileAccessMode::Read,
-                                         Common::FS::FileType::BinaryFile};
+    const Common::FS::IOFile nfc_file{filename, Common::FS::FileAccessMode::Read,
+                                      Common::FS::FileType::BinaryFile};
 
     if (state != State::WaitingForAmiibo) {
         return Info::WrongDeviceState;
     }
 
-    if (!amiibo_file.IsOpen()) {
+    if (!nfc_file.IsOpen()) {
         return Info::UnableToLoad;
     }
 
-    amiibo_data.resize(amiibo_size);
-
-    if (amiibo_file.Read(amiibo_data) < amiibo_size_without_password) {
+    switch (nfc_file.GetSize()) {
+    case AmiiboSize:
+    case AmiiboSizeWithoutPassword:
+        nfc_data.resize(AmiiboSize);
+        if (nfc_file.Read(nfc_data) < AmiiboSizeWithoutPassword) {
+            return Info::NotAnAmiibo;
+        }
+        break;
+    case MifareSize:
+        nfc_data.resize(MifareSize);
+        if (nfc_file.Read(nfc_data) < MifareSize) {
+            return Info::NotAnAmiibo;
+        }
+        break;
+    default:
         return Info::NotAnAmiibo;
     }
 
     file_path = filename;
     state = State::AmiiboIsOpen;
-    SetNfc(identifier, {Common::Input::NfcState::NewAmiibo, amiibo_data});
+    SetNfc(identifier, {Common::Input::NfcState::NewAmiibo, nfc_data});
     return Info::Success;
 }
 
 VirtualAmiibo::Info VirtualAmiibo::ReloadAmiibo() {
     if (state == State::AmiiboIsOpen) {
-        SetNfc(identifier, {Common::Input::NfcState::NewAmiibo, amiibo_data});
+        SetNfc(identifier, {Common::Input::NfcState::NewAmiibo, nfc_data});
         return Info::Success;
     }
 

src/input_common/drivers/virtual_amiibo.h

@@ -53,12 +53,13 @@ public:
     std::string GetLastFilePath() const;
 
 private:
-    static constexpr std::size_t amiibo_size = 0x21C;
-    static constexpr std::size_t amiibo_size_without_password = amiibo_size - 0x8;
+    static constexpr std::size_t AmiiboSize = 0x21C;
+    static constexpr std::size_t AmiiboSizeWithoutPassword = AmiiboSize - 0x8;
+    static constexpr std::size_t MifareSize = 0x400;
 
     std::string file_path{};
     State state{State::Initialized};
-    std::vector<u8> amiibo_data;
+    std::vector<u8> nfc_data;
     Common::Input::PollingMode polling_mode{Common::Input::PollingMode::Pasive};
 };
 } // namespace InputCommon

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -1345,8 +1345,10 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     if (info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
         (profile.warp_size_potentially_larger_than_guest &&
          (info.uses_subgroup_vote || info.uses_subgroup_mask))) {
+        AddCapability(spv::Capability::GroupNonUniform);
         subgroup_local_invocation_id =
             DefineInput(*this, U32[1], false, spv::BuiltIn::SubgroupLocalInvocationId);
+        Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
     }
     if (info.uses_fswzadd) {
         const Id f32_one{Const(1.0f)};

src/video_core/CMakeLists.txt

@@ -33,6 +33,8 @@ add_library(video_core STATIC
     engines/sw_blitter/converter.cpp
     engines/sw_blitter/converter.h
     engines/const_buffer_info.h
+    engines/draw_manager.cpp
+    engines/draw_manager.h
     engines/engine_interface.h
     engines/engine_upload.cpp
     engines/engine_upload.h
@@ -176,6 +178,8 @@ add_library(video_core STATIC
     renderer_vulkan/vk_scheduler.h
     renderer_vulkan/vk_shader_util.cpp
     renderer_vulkan/vk_shader_util.h
+    renderer_vulkan/vk_smaa.cpp
+    renderer_vulkan/vk_smaa.h
     renderer_vulkan/vk_staging_buffer_pool.cpp
     renderer_vulkan/vk_staging_buffer_pool.h
     renderer_vulkan/vk_state_tracker.cpp
@@ -193,6 +197,8 @@ add_library(video_core STATIC
     shader_environment.h
     shader_notify.cpp
     shader_notify.h
+    smaa_area_tex.h
+    smaa_search_tex.h
     surface.cpp
     surface.h
     texture_cache/accelerated_swizzle.cpp

src/video_core/buffer_cache/buffer_cache.h

@@ -26,6 +26,7 @@
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/delayed_destruction_ring.h"
 #include "video_core/dirty_flags.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/memory_manager.h"
@@ -664,9 +665,10 @@ void BufferCache<P>::BindHostGeometryBuffers(bool is_indexed) {
     if (is_indexed) {
         BindHostIndexBuffer();
     } else if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-        const auto& regs = maxwell3d->regs;
-        if (regs.draw.topology == Maxwell::PrimitiveTopology::Quads) {
-            runtime.BindQuadArrayIndexBuffer(regs.vertex_buffer.first, regs.vertex_buffer.count);
+        const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+        if (draw_state.topology == Maxwell::PrimitiveTopology::Quads) {
+            runtime.BindQuadArrayIndexBuffer(draw_state.vertex_buffer.first,
+                                             draw_state.vertex_buffer.count);
         }
     }
     BindHostVertexBuffers();
@@ -993,28 +995,29 @@ void BufferCache<P>::BindHostIndexBuffer() {
     TouchBuffer(buffer, index_buffer.buffer_id);
     const u32 offset = buffer.Offset(index_buffer.cpu_addr);
     const u32 size = index_buffer.size;
-    if (maxwell3d->inline_index_draw_indexes.size()) {
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+    if (!draw_state.inline_index_draw_indexes.empty()) {
         if constexpr (USE_MEMORY_MAPS) {
             auto upload_staging = runtime.UploadStagingBuffer(size);
             std::array<BufferCopy, 1> copies{
                 {BufferCopy{.src_offset = upload_staging.offset, .dst_offset = 0, .size = size}}};
             std::memcpy(upload_staging.mapped_span.data(),
-                        maxwell3d->inline_index_draw_indexes.data(), size);
+                        draw_state.inline_index_draw_indexes.data(), size);
             runtime.CopyBuffer(buffer, upload_staging.buffer, copies);
         } else {
-            buffer.ImmediateUpload(0, maxwell3d->inline_index_draw_indexes);
+            buffer.ImmediateUpload(0, draw_state.inline_index_draw_indexes);
         }
     } else {
         SynchronizeBuffer(buffer, index_buffer.cpu_addr, size);
     }
     if constexpr (HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-        const u32 new_offset = offset + maxwell3d->regs.index_buffer.first *
-                                            maxwell3d->regs.index_buffer.FormatSizeInBytes();
+        const u32 new_offset =
+            offset + draw_state.index_buffer.first * draw_state.index_buffer.FormatSizeInBytes();
         runtime.BindIndexBuffer(buffer, new_offset, size);
     } else {
-        runtime.BindIndexBuffer(maxwell3d->regs.draw.topology, maxwell3d->regs.index_buffer.format,
-                                maxwell3d->regs.index_buffer.first,
-                                maxwell3d->regs.index_buffer.count, buffer, offset, size);
+        runtime.BindIndexBuffer(draw_state.topology, draw_state.index_buffer.format,
+                                draw_state.index_buffer.first, draw_state.index_buffer.count,
+                                buffer, offset, size);
     }
 }
 
@@ -1282,15 +1285,16 @@ template <class P>
 void BufferCache<P>::UpdateIndexBuffer() {
     // We have to check for the dirty flags and index count
     // The index count is currently changed without updating the dirty flags
-    const auto& index_array = maxwell3d->regs.index_buffer;
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+    const auto& index_array = draw_state.index_buffer;
     auto& flags = maxwell3d->dirty.flags;
     if (!flags[Dirty::IndexBuffer] && last_index_count == index_array.count) {
         return;
     }
     flags[Dirty::IndexBuffer] = false;
     last_index_count = index_array.count;
-    if (maxwell3d->inline_index_draw_indexes.size()) {
-        auto inline_index_size = static_cast<u32>(maxwell3d->inline_index_draw_indexes.size());
+    if (!draw_state.inline_index_draw_indexes.empty()) {
+        auto inline_index_size = static_cast<u32>(draw_state.inline_index_draw_indexes.size());
         index_buffer = Binding{
             .cpu_addr = 0,
             .size = inline_index_size,

src/video_core/engines/draw_manager.cpp

@@ -0,0 +1,201 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "video_core/dirty_flags.h"
+#include "video_core/engines/draw_manager.h"
+#include "video_core/rasterizer_interface.h"
+
+namespace Tegra::Engines {
+DrawManager::DrawManager(Maxwell3D* maxwell3d_) : maxwell3d(maxwell3d_) {}
+
+void DrawManager::ProcessMethodCall(u32 method, u32 argument) {
+    const auto& regs{maxwell3d->regs};
+    switch (method) {
+    case MAXWELL3D_REG_INDEX(clear_surface):
+        return Clear(1);
+    case MAXWELL3D_REG_INDEX(draw.begin):
+        return DrawBegin();
+    case MAXWELL3D_REG_INDEX(draw.end):
+        return DrawEnd();
+    case MAXWELL3D_REG_INDEX(vertex_buffer.first):
+    case MAXWELL3D_REG_INDEX(vertex_buffer.count):
+    case MAXWELL3D_REG_INDEX(index_buffer.first):
+        break;
+    case MAXWELL3D_REG_INDEX(index_buffer.count):
+        draw_state.draw_indexed = true;
+        break;
+    case MAXWELL3D_REG_INDEX(index_buffer32_subsequent):
+    case MAXWELL3D_REG_INDEX(index_buffer16_subsequent):
+    case MAXWELL3D_REG_INDEX(index_buffer8_subsequent):
+        draw_state.instance_count++;
+        [[fallthrough]];
+    case MAXWELL3D_REG_INDEX(index_buffer32_first):
+    case MAXWELL3D_REG_INDEX(index_buffer16_first):
+    case MAXWELL3D_REG_INDEX(index_buffer8_first):
+        return DrawIndexSmall(argument);
+    case MAXWELL3D_REG_INDEX(draw_inline_index):
+        SetInlineIndexBuffer(argument);
+        break;
+    case MAXWELL3D_REG_INDEX(inline_index_2x16.even):
+        SetInlineIndexBuffer(regs.inline_index_2x16.even);
+        SetInlineIndexBuffer(regs.inline_index_2x16.odd);
+        break;
+    case MAXWELL3D_REG_INDEX(inline_index_4x8.index0):
+        SetInlineIndexBuffer(regs.inline_index_4x8.index0);
+        SetInlineIndexBuffer(regs.inline_index_4x8.index1);
+        SetInlineIndexBuffer(regs.inline_index_4x8.index2);
+        SetInlineIndexBuffer(regs.inline_index_4x8.index3);
+        break;
+    case MAXWELL3D_REG_INDEX(vertex_array_instance_first):
+    case MAXWELL3D_REG_INDEX(vertex_array_instance_subsequent): {
+        LOG_WARNING(HW_GPU, "(STUBBED) called");
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+void DrawManager::Clear(u32 layer_count) {
+    if (maxwell3d->ShouldExecute()) {
+        maxwell3d->rasterizer->Clear(layer_count);
+    }
+}
+
+void DrawManager::DrawDeferred() {
+    if (draw_state.draw_mode != DrawMode::Instance || draw_state.instance_count == 0) {
+        return;
+    }
+    DrawEnd(draw_state.instance_count + 1, true);
+    draw_state.instance_count = 0;
+}
+
+void DrawManager::DrawArray(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
+                            u32 base_instance, u32 num_instances) {
+    draw_state.topology = topology;
+    draw_state.vertex_buffer.first = vertex_first;
+    draw_state.vertex_buffer.count = vertex_count;
+    draw_state.base_instance = base_instance;
+    ProcessDraw(false, num_instances);
+}
+
+void DrawManager::DrawIndex(PrimitiveTopology topology, u32 index_first, u32 index_count,
+                            u32 base_index, u32 base_instance, u32 num_instances) {
+    const auto& regs{maxwell3d->regs};
+    draw_state.topology = topology;
+    draw_state.index_buffer = regs.index_buffer;
+    draw_state.index_buffer.first = index_first;
+    draw_state.index_buffer.count = index_count;
+    draw_state.base_index = base_index;
+    draw_state.base_instance = base_instance;
+    ProcessDraw(true, num_instances);
+}
+
+void DrawManager::SetInlineIndexBuffer(u32 index) {
+    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>(index & 0x000000ff));
+    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>((index & 0x0000ff00) >> 8));
+    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>((index & 0x00ff0000) >> 16));
+    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>((index & 0xff000000) >> 24));
+    draw_state.draw_mode = DrawMode::InlineIndex;
+}
+
+void DrawManager::DrawBegin() {
+    const auto& regs{maxwell3d->regs};
+    auto reset_instance_count = regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::First;
+    auto increment_instance_count =
+        regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent;
+    if (reset_instance_count) {
+        DrawDeferred();
+        draw_state.instance_count = 0;
+        draw_state.draw_mode = DrawMode::General;
+    } else if (increment_instance_count) {
+        draw_state.instance_count++;
+        draw_state.draw_mode = DrawMode::Instance;
+    }
+
+    draw_state.topology = regs.draw.topology;
+}
+
+void DrawManager::DrawEnd(u32 instance_count, bool force_draw) {
+    const auto& regs{maxwell3d->regs};
+    switch (draw_state.draw_mode) {
+    case DrawMode::Instance:
+        if (!force_draw) {
+            break;
+        }
+        [[fallthrough]];
+    case DrawMode::General:
+        draw_state.base_instance = regs.global_base_instance_index;
+        draw_state.base_index = regs.global_base_vertex_index;
+        if (draw_state.draw_indexed) {
+            draw_state.index_buffer = regs.index_buffer;
+            ProcessDraw(true, instance_count);
+        } else {
+            draw_state.vertex_buffer = regs.vertex_buffer;
+            ProcessDraw(false, instance_count);
+        }
+        draw_state.draw_indexed = false;
+        break;
+    case DrawMode::InlineIndex:
+        draw_state.base_instance = regs.global_base_instance_index;
+        draw_state.base_index = regs.global_base_vertex_index;
+        draw_state.index_buffer = regs.index_buffer;
+        draw_state.index_buffer.count =
+            static_cast<u32>(draw_state.inline_index_draw_indexes.size() / 4);
+        draw_state.index_buffer.format = Maxwell3D::Regs::IndexFormat::UnsignedInt;
+        ProcessDraw(true, instance_count);
+        draw_state.inline_index_draw_indexes.clear();
+        break;
+    }
+}
+
+void DrawManager::DrawIndexSmall(u32 argument) {
+    const auto& regs{maxwell3d->regs};
+    IndexBufferSmall index_small_params{argument};
+    draw_state.base_instance = regs.global_base_instance_index;
+    draw_state.base_index = regs.global_base_vertex_index;
+    draw_state.index_buffer = regs.index_buffer;
+    draw_state.index_buffer.first = index_small_params.first;
+    draw_state.index_buffer.count = index_small_params.count;
+    draw_state.topology = index_small_params.topology;
+    maxwell3d->dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+    ProcessDraw(true, 1);
+}
+
+void DrawManager::UpdateTopology() {
+    const auto& regs{maxwell3d->regs};
+    switch (regs.primitive_topology_control) {
+    case PrimitiveTopologyControl::UseInBeginMethods:
+        break;
+    case PrimitiveTopologyControl::UseSeparateState:
+        switch (regs.topology_override) {
+        case PrimitiveTopologyOverride::None:
+            break;
+        case PrimitiveTopologyOverride::Points:
+            draw_state.topology = PrimitiveTopology::Points;
+            break;
+        case PrimitiveTopologyOverride::Lines:
+            draw_state.topology = PrimitiveTopology::Lines;
+            break;
+        case PrimitiveTopologyOverride::LineStrip:
+            draw_state.topology = PrimitiveTopology::LineStrip;
+            break;
+        default:
+            draw_state.topology = static_cast<PrimitiveTopology>(regs.topology_override);
+            break;
+        }
+        break;
+    }
+}
+
+void DrawManager::ProcessDraw(bool draw_indexed, u32 instance_count) {
+    LOG_TRACE(HW_GPU, "called, topology={}, count={}", draw_state.topology,
+              draw_indexed ? draw_state.index_buffer.count : draw_state.vertex_buffer.count);
+
+    UpdateTopology();
+
+    if (maxwell3d->ShouldExecute()) {
+        maxwell3d->rasterizer->Draw(draw_indexed, instance_count);
+    }
+}
+} // namespace Tegra::Engines

src/video_core/engines/draw_manager.h

@@ -0,0 +1,69 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include "common/common_types.h"
+#include "video_core/engines/maxwell_3d.h"
+
+namespace VideoCore {
+class RasterizerInterface;
+}
+
+namespace Tegra::Engines {
+using PrimitiveTopologyControl = Maxwell3D::Regs::PrimitiveTopologyControl;
+using PrimitiveTopology = Maxwell3D::Regs::PrimitiveTopology;
+using PrimitiveTopologyOverride = Maxwell3D::Regs::PrimitiveTopologyOverride;
+using IndexBuffer = Maxwell3D::Regs::IndexBuffer;
+using VertexBuffer = Maxwell3D::Regs::VertexBuffer;
+using IndexBufferSmall = Maxwell3D::Regs::IndexBufferSmall;
+
+class DrawManager {
+public:
+    enum class DrawMode : u32 { General = 0, Instance, InlineIndex };
+    struct State {
+        PrimitiveTopology topology{};
+        DrawMode draw_mode{};
+        bool draw_indexed{};
+        u32 base_index{};
+        VertexBuffer vertex_buffer;
+        IndexBuffer index_buffer;
+        u32 base_instance{};
+        u32 instance_count{};
+        std::vector<u8> inline_index_draw_indexes;
+    };
+
+    explicit DrawManager(Maxwell3D* maxwell_3d);
+
+    void ProcessMethodCall(u32 method, u32 argument);
+
+    void Clear(u32 layer_count);
+
+    void DrawDeferred();
+
+    void DrawArray(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
+                   u32 base_instance, u32 num_instances);
+
+    void DrawIndex(PrimitiveTopology topology, u32 index_first, u32 index_count, u32 base_index,
+                   u32 base_instance, u32 num_instances);
+
+    const State& GetDrawState() const {
+        return draw_state;
+    }
+
+private:
+    void SetInlineIndexBuffer(u32 index);
+
+    void DrawBegin();
+
+    void DrawEnd(u32 instance_count = 1, bool force_draw = false);
+
+    void DrawIndexSmall(u32 argument);
+
+    void UpdateTopology();
+
+    void ProcessDraw(bool draw_indexed, u32 instance_count);
+
+    Maxwell3D* maxwell3d{};
+    State draw_state{};
+};
+} // namespace Tegra::Engines

src/video_core/engines/maxwell_3d.cpp

@@ -7,6 +7,7 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "video_core/dirty_flags.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
@@ -21,8 +22,10 @@ using VideoCore::QueryType;
 constexpr u32 MacroRegistersStart = 0xE00;
 
 Maxwell3D::Maxwell3D(Core::System& system_, MemoryManager& memory_manager_)
-    : system{system_}, memory_manager{memory_manager_}, macro_engine{GetMacroEngine(*this)},
-      upload_state{memory_manager, regs.upload} {
+    : draw_manager{std::make_unique<DrawManager>(this)}, system{system_},
+      memory_manager{memory_manager_}, macro_engine{GetMacroEngine(*this)}, upload_state{
+                                                                                memory_manager,
+                                                                                regs.upload} {
     dirty.flags.flip();
     InitializeRegisterDefaults();
 }
@@ -116,16 +119,6 @@ void Maxwell3D::InitializeRegisterDefaults() {
     regs.polygon_mode_front = Maxwell3D::Regs::PolygonMode::Fill;
 
     shadow_state = regs;
-
-    draw_command[MAXWELL3D_REG_INDEX(draw.end)] = true;
-    draw_command[MAXWELL3D_REG_INDEX(draw.begin)] = true;
-    draw_command[MAXWELL3D_REG_INDEX(vertex_buffer.first)] = true;
-    draw_command[MAXWELL3D_REG_INDEX(vertex_buffer.count)] = true;
-    draw_command[MAXWELL3D_REG_INDEX(index_buffer.first)] = true;
-    draw_command[MAXWELL3D_REG_INDEX(index_buffer.count)] = true;
-    draw_command[MAXWELL3D_REG_INDEX(draw_inline_index)] = true;
-    draw_command[MAXWELL3D_REG_INDEX(inline_index_2x16.even)] = true;
-    draw_command[MAXWELL3D_REG_INDEX(inline_index_4x8.index0)] = true;
 }
 
 void Maxwell3D::ProcessMacro(u32 method, const u32* base_start, u32 amount, bool is_last_call) {
@@ -213,29 +206,6 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
         return ProcessCBBind(3);
     case MAXWELL3D_REG_INDEX(bind_groups[4].raw_config):
         return ProcessCBBind(4);
-    case MAXWELL3D_REG_INDEX(index_buffer32_first):
-        regs.index_buffer.count = regs.index_buffer32_first.count;
-        regs.index_buffer.first = regs.index_buffer32_first.first;
-        dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-        draw_indexed = true;
-        return ProcessDraw();
-    case MAXWELL3D_REG_INDEX(index_buffer16_first):
-        regs.index_buffer.count = regs.index_buffer16_first.count;
-        regs.index_buffer.first = regs.index_buffer16_first.first;
-        dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-        draw_indexed = true;
-        return ProcessDraw();
-    case MAXWELL3D_REG_INDEX(index_buffer8_first):
-        regs.index_buffer.count = regs.index_buffer8_first.count;
-        regs.index_buffer.first = regs.index_buffer8_first.first;
-        dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-        draw_indexed = true;
-        return ProcessDraw();
-    case MAXWELL3D_REG_INDEX(topology_override):
-        use_topology_override = true;
-        return;
-    case MAXWELL3D_REG_INDEX(clear_surface):
-        return ProcessClearBuffers(1);
     case MAXWELL3D_REG_INDEX(report_semaphore.query):
         return ProcessQueryGet();
     case MAXWELL3D_REG_INDEX(render_enable.mode):
@@ -254,6 +224,9 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
         return rasterizer->FragmentBarrier();
     case MAXWELL3D_REG_INDEX(tiled_cache_barrier):
         return rasterizer->TiledCacheBarrier();
+    default:
+        draw_manager->ProcessMethodCall(method, argument);
+        break;
     }
 }
 
@@ -268,7 +241,7 @@ void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters)
     // Execute the current macro.
     macro_engine->Execute(macro_positions[entry], parameters);
 
-    ProcessDeferredDraw();
+    draw_manager->DrawDeferred();
 }
 
 void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
@@ -291,62 +264,7 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
     const u32 argument = ProcessShadowRam(method, method_argument);
     ProcessDirtyRegisters(method, argument);
 
-    if (draw_command[method]) {
-        regs.reg_array[method] = method_argument;
-        deferred_draw_method.push_back(method);
-        auto update_inline_index = [&](const u32 index) {
-            inline_index_draw_indexes.push_back(static_cast<u8>(index & 0x000000ff));
-            inline_index_draw_indexes.push_back(static_cast<u8>((index & 0x0000ff00) >> 8));
-            inline_index_draw_indexes.push_back(static_cast<u8>((index & 0x00ff0000) >> 16));
-            inline_index_draw_indexes.push_back(static_cast<u8>((index & 0xff000000) >> 24));
-            draw_mode = DrawMode::InlineIndex;
-        };
-        switch (method) {
-        case MAXWELL3D_REG_INDEX(draw.begin): {
-            draw_mode =
-                (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent) ||
-                        (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Unchanged)
-                    ? DrawMode::Instance
-                    : DrawMode::General;
-            break;
-        }
-        case MAXWELL3D_REG_INDEX(draw.end):
-            switch (draw_mode) {
-            case DrawMode::General:
-                ProcessDraw();
-                break;
-            case DrawMode::InlineIndex:
-                regs.index_buffer.count = static_cast<u32>(inline_index_draw_indexes.size() / 4);
-                regs.index_buffer.format = Regs::IndexFormat::UnsignedInt;
-                draw_indexed = true;
-                ProcessDraw();
-                inline_index_draw_indexes.clear();
-                break;
-            case DrawMode::Instance:
-                break;
-            }
-            break;
-        case MAXWELL3D_REG_INDEX(index_buffer.count):
-            draw_indexed = true;
-            break;
-        case MAXWELL3D_REG_INDEX(draw_inline_index):
-            update_inline_index(method_argument);
-            break;
-        case MAXWELL3D_REG_INDEX(inline_index_2x16.even):
-            update_inline_index(regs.inline_index_2x16.even);
-            update_inline_index(regs.inline_index_2x16.odd);
-            break;
-        case MAXWELL3D_REG_INDEX(inline_index_4x8.index0):
-            update_inline_index(regs.inline_index_4x8.index0);
-            update_inline_index(regs.inline_index_4x8.index1);
-            update_inline_index(regs.inline_index_4x8.index2);
-            update_inline_index(regs.inline_index_4x8.index3);
-            break;
-        }
-    } else {
-        ProcessDeferredDraw();
-        ProcessMethodCall(method, argument, method_argument, is_last_call);
-    }
+    ProcessMethodCall(method, argument, method_argument, is_last_call);
 }
 
 void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
@@ -387,35 +305,6 @@ void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
     }
 }
 
-void Maxwell3D::ProcessTopologyOverride() {
-    using PrimitiveTopology = Maxwell3D::Regs::PrimitiveTopology;
-    using PrimitiveTopologyOverride = Maxwell3D::Regs::PrimitiveTopologyOverride;
-
-    PrimitiveTopology topology{};
-
-    switch (regs.topology_override) {
-    case PrimitiveTopologyOverride::None:
-        topology = regs.draw.topology;
-        break;
-    case PrimitiveTopologyOverride::Points:
-        topology = PrimitiveTopology::Points;
-        break;
-    case PrimitiveTopologyOverride::Lines:
-        topology = PrimitiveTopology::Lines;
-        break;
-    case PrimitiveTopologyOverride::LineStrip:
-        topology = PrimitiveTopology::LineStrip;
-        break;
-    default:
-        topology = static_cast<PrimitiveTopology>(regs.topology_override);
-        break;
-    }
-
-    if (use_topology_override) {
-        regs.draw.topology.Assign(topology);
-    }
-}
-
 void Maxwell3D::ProcessMacroUpload(u32 data) {
     macro_engine->AddCode(regs.load_mme.instruction_ptr++, data);
 }
@@ -493,41 +382,51 @@ void Maxwell3D::ProcessQueryGet() {
 
 void Maxwell3D::ProcessQueryCondition() {
     const GPUVAddr condition_address{regs.render_enable.Address()};
-    switch (regs.render_enable.mode) {
-    case Regs::RenderEnable::Mode::True: {
+    switch (regs.render_enable_override) {
+    case Regs::RenderEnable::Override::AlwaysRender:
         execute_on = true;
         break;
-    }
-    case Regs::RenderEnable::Mode::False: {
+    case Regs::RenderEnable::Override::NeverRender:
         execute_on = false;
         break;
-    }
-    case Regs::RenderEnable::Mode::Conditional: {
-        Regs::ReportSemaphore::Compare cmp;
-        memory_manager.ReadBlock(condition_address, &cmp, sizeof(cmp));
-        execute_on = cmp.initial_sequence != 0U && cmp.initial_mode != 0U;
+    case Regs::RenderEnable::Override::UseRenderEnable:
+        switch (regs.render_enable.mode) {
+        case Regs::RenderEnable::Mode::True: {
+            execute_on = true;
+            break;
+        }
+        case Regs::RenderEnable::Mode::False: {
+            execute_on = false;
+            break;
+        }
+        case Regs::RenderEnable::Mode::Conditional: {
+            Regs::ReportSemaphore::Compare cmp;
+            memory_manager.ReadBlock(condition_address, &cmp, sizeof(cmp));
+            execute_on = cmp.initial_sequence != 0U && cmp.initial_mode != 0U;
+            break;
+        }
+        case Regs::RenderEnable::Mode::IfEqual: {
+            Regs::ReportSemaphore::Compare cmp;
+            memory_manager.ReadBlock(condition_address, &cmp, sizeof(cmp));
+            execute_on = cmp.initial_sequence == cmp.current_sequence &&
+                         cmp.initial_mode == cmp.current_mode;
+            break;
+        }
+        case Regs::RenderEnable::Mode::IfNotEqual: {
+            Regs::ReportSemaphore::Compare cmp;
+            memory_manager.ReadBlock(condition_address, &cmp, sizeof(cmp));
+            execute_on = cmp.initial_sequence != cmp.current_sequence ||
+                         cmp.initial_mode != cmp.current_mode;
+            break;
+        }
+        default: {
+            UNIMPLEMENTED_MSG("Uninplemented Condition Mode!");
+            execute_on = true;
+            break;
+        }
+        }
         break;
     }
-    case Regs::RenderEnable::Mode::IfEqual: {
-        Regs::ReportSemaphore::Compare cmp;
-        memory_manager.ReadBlock(condition_address, &cmp, sizeof(cmp));
-        execute_on =
-            cmp.initial_sequence == cmp.current_sequence && cmp.initial_mode == cmp.current_mode;
-        break;
-    }
-    case Regs::RenderEnable::Mode::IfNotEqual: {
-        Regs::ReportSemaphore::Compare cmp;
-        memory_manager.ReadBlock(condition_address, &cmp, sizeof(cmp));
-        execute_on =
-            cmp.initial_sequence != cmp.current_sequence || cmp.initial_mode != cmp.current_mode;
-        break;
-    }
-    default: {
-        UNIMPLEMENTED_MSG("Uninplemented Condition Mode!");
-        execute_on = true;
-        break;
-    }
-    }
 }
 
 void Maxwell3D::ProcessCounterReset() {
@@ -625,44 +524,4 @@ u32 Maxwell3D::GetRegisterValue(u32 method) const {
     return regs.reg_array[method];
 }
 
-void Maxwell3D::ProcessClearBuffers(u32 layer_count) {
-    rasterizer->Clear(layer_count);
-}
-
-void Maxwell3D::ProcessDraw(u32 instance_count) {
-    LOG_TRACE(HW_GPU, "called, topology={}, count={}", regs.draw.topology.Value(),
-              draw_indexed ? regs.index_buffer.count : regs.vertex_buffer.count);
-
-    ProcessTopologyOverride();
-
-    if (ShouldExecute()) {
-        rasterizer->Draw(draw_indexed, instance_count);
-    }
-
-    draw_indexed = false;
-    deferred_draw_method.clear();
-}
-
-void Maxwell3D::ProcessDeferredDraw() {
-    if (draw_mode != DrawMode::Instance || deferred_draw_method.empty()) {
-        return;
-    }
-
-    const auto method_count = deferred_draw_method.size();
-    u32 instance_count = 1;
-    u32 vertex_buffer_count = 0;
-    u32 index_buffer_count = 0;
-    for (size_t index = 0; index < method_count; ++index) {
-        const u32 method = deferred_draw_method[index];
-        if (method == MAXWELL3D_REG_INDEX(vertex_buffer.count)) {
-            instance_count = ++vertex_buffer_count;
-        } else if (method == MAXWELL3D_REG_INDEX(index_buffer.count)) {
-            instance_count = ++index_buffer_count;
-        }
-    }
-    ASSERT_MSG(!(vertex_buffer_count && index_buffer_count), "Instance both indexed and direct?");
-
-    ProcessDraw(instance_count);
-}
-
 } // namespace Tegra::Engines

src/video_core/engines/maxwell_3d.h

@@ -37,6 +37,8 @@ class RasterizerInterface;
 
 namespace Tegra::Engines {
 
+class DrawManager;
+
 /**
  * This Engine is known as GF100_3D. Documentation can be found in:
  * https://github.com/NVIDIA/open-gpu-doc/blob/master/classes/3d/clb197.h
@@ -2223,6 +2225,7 @@ public:
 
         struct IndexBufferSmall {
             union {
+                u32 raw;
                 BitField<0, 16, u32> first;
                 BitField<16, 12, u32> count;
                 BitField<28, 4, PrimitiveTopology> topology;
@@ -3061,10 +3064,8 @@ public:
         Tables tables{};
     } dirty;
 
-    std::vector<u8> inline_index_draw_indexes;
-
-    /// Handles a write to the CLEAR_BUFFERS register.
-    void ProcessClearBuffers(u32 layer_count);
+    std::unique_ptr<DrawManager> draw_manager;
+    friend class DrawManager;
 
 private:
     void InitializeRegisterDefaults();
@@ -3122,15 +3123,6 @@ private:
     /// Handles a write to the CB_BIND register.
     void ProcessCBBind(size_t stage_index);
 
-    /// Handles use of topology overrides (e.g., to avoid using a topology assigned from a macro)
-    void ProcessTopologyOverride();
-
-    /// Handles deferred draw(e.g., instance draw).
-    void ProcessDeferredDraw();
-
-    /// Handles a draw.
-    void ProcessDraw(u32 instance_count = 1);
-
     /// Returns a query's value or an empty object if the value will be deferred through a cache.
     std::optional<u64> GetQueryResult();
 
@@ -3153,13 +3145,6 @@ private:
     Upload::State upload_state;
 
     bool execute_on{true};
-    bool use_topology_override{false};
-
-    std::array<bool, Regs::NUM_REGS> draw_command{};
-    std::vector<u32> deferred_draw_method;
-    enum class DrawMode : u32 { General = 0, Instance, InlineIndex };
-    DrawMode draw_mode{DrawMode::General};
-    bool draw_indexed{};
 };
 
 #define ASSERT_REG_POSITION(field_name, position)                                                  \

src/video_core/gpu.cpp

@@ -223,8 +223,6 @@ struct GPU::Impl {
     /// core timing events.
     void Start() {
         gpu_thread.StartThread(*renderer, renderer->Context(), *scheduler);
-        cpu_context = renderer->GetRenderWindow().CreateSharedContext();
-        cpu_context->MakeCurrent();
     }
 
     void NotifyShutdown() {
@@ -235,6 +233,9 @@ struct GPU::Impl {
 
     /// Obtain the CPU Context
     void ObtainContext() {
+        if (!cpu_context) {
+            cpu_context = renderer->GetRenderWindow().CreateSharedContext();
+        }
         cpu_context->MakeCurrent();
     }
 

src/video_core/host_shaders/CMakeLists.txt

@@ -26,9 +26,16 @@ set(SHADER_FILES
     opengl_present.frag
     opengl_present.vert
     opengl_present_scaleforce.frag
+    opengl_smaa.glsl
     pitch_unswizzle.comp
     present_bicubic.frag
     present_gaussian.frag
+    smaa_edge_detection.vert
+    smaa_edge_detection.frag
+    smaa_blending_weight_calculation.vert
+    smaa_blending_weight_calculation.frag
+    smaa_neighborhood_blending.vert
+    smaa_neighborhood_blending.frag
     vulkan_blit_color_float.frag
     vulkan_blit_depth_stencil.frag
     vulkan_fidelityfx_fsr_easu_fp16.comp

src/video_core/host_shaders/StringShaderHeader.cmake

@@ -11,10 +11,6 @@ string(TOUPPER ${CONTENTS_NAME} CONTENTS_NAME)
 
 FILE(READ ${SOURCE_FILE} line_contents)
 
-# Replace double quotes with single quotes,
-# as double quotes will be used to wrap the lines
-STRING(REGEX REPLACE "\"" "'" line_contents "${line_contents}")
-
 # CMake separates list elements with semicolons, but semicolons
 # are used extensively in the shader code.
 # Replace with a temporary marker, to be reverted later.
@@ -25,7 +21,7 @@ STRING(REGEX REPLACE "\n" ";" line_contents "${line_contents}")
 
 # Build the shader string, wrapping each line in double quotes.
 foreach(line IN LISTS line_contents)
-    string(CONCAT CONTENTS "${CONTENTS}" \"${line}\\n\"\n)
+    string(CONCAT CONTENTS "${CONTENTS}" "R\"(${line}\n)\" ")
 endforeach()
 
 # Revert the original semicolons in the source.

src/video_core/host_shaders/smaa_blending_weight_calculation.frag

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460
+
+#extension GL_GOOGLE_include_directive : enable
+
+layout (binding = 0) uniform sampler2D edges_tex;
+layout (binding = 1) uniform sampler2D area_tex;
+layout (binding = 2) uniform sampler2D search_tex;
+
+layout (location = 0) in vec2 tex_coord;
+layout (location = 1) in vec2 pix_coord;
+layout (location = 2) in vec4 offset[3];
+
+layout (location = 0) out vec4 frag_color;
+
+vec4 metrics = vec4(1.0 / textureSize(edges_tex, 0), textureSize(edges_tex, 0));
+#define SMAA_RT_METRICS metrics
+#define SMAA_GLSL_4
+#define SMAA_PRESET_ULTRA
+#define SMAA_INCLUDE_VS 0
+#define SMAA_INCLUDE_PS 1
+
+#include "opengl_smaa.glsl"
+
+void main() {
+    frag_color = SMAABlendingWeightCalculationPS(tex_coord,
+                                       pix_coord,
+                                       offset,
+                                       edges_tex,
+                                       area_tex,
+                                       search_tex,
+                                       vec4(0)
+                                       );
+}

src/video_core/host_shaders/smaa_blending_weight_calculation.vert

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460
+
+#extension GL_GOOGLE_include_directive : enable
+
+#ifdef VULKAN
+#define VERTEX_ID gl_VertexIndex
+#else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
+#define VERTEX_ID gl_VertexID
+#endif
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+const vec2 vertices[3] =
+    vec2[3](vec2(-1,-1), vec2(3,-1), vec2(-1, 3));
+
+layout (binding = 0) uniform sampler2D edges_tex;
+layout (binding = 1) uniform sampler2D area_tex;
+layout (binding = 2) uniform sampler2D search_tex;
+
+layout (location = 0) out vec2 tex_coord;
+layout (location = 1) out vec2 pix_coord;
+layout (location = 2) out vec4 offset[3];
+
+vec4 metrics = vec4(1.0 / textureSize(edges_tex, 0), textureSize(edges_tex, 0));
+#define SMAA_RT_METRICS metrics
+#define SMAA_GLSL_4
+#define SMAA_PRESET_ULTRA
+#define SMAA_INCLUDE_VS 1
+#define SMAA_INCLUDE_PS 0
+
+#include "opengl_smaa.glsl"
+
+void main() {
+    vec2 vertex = vertices[VERTEX_ID];
+    gl_Position = vec4(vertex, 0.0, 1.0);
+    tex_coord = (vertex + 1.0) / 2.0;
+    SMAABlendingWeightCalculationVS(tex_coord, pix_coord, offset);
+}

src/video_core/host_shaders/smaa_edge_detection.frag

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460
+
+#extension GL_GOOGLE_include_directive : enable
+
+layout (binding = 0) uniform sampler2D input_tex;
+
+layout (location = 0) in vec2 tex_coord;
+layout (location = 1) in vec4 offset[3];
+
+layout (location = 0) out vec2 frag_color;
+
+vec4 metrics = vec4(1.0 / textureSize(input_tex, 0), textureSize(input_tex, 0));
+#define SMAA_RT_METRICS metrics
+#define SMAA_GLSL_4
+#define SMAA_PRESET_ULTRA
+#define SMAA_INCLUDE_VS 0
+#define SMAA_INCLUDE_PS 1
+
+#include "opengl_smaa.glsl"
+
+void main() {
+    frag_color = SMAAColorEdgeDetectionPS(tex_coord, offset, input_tex);
+}

src/video_core/host_shaders/smaa_edge_detection.vert

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460
+
+#extension GL_GOOGLE_include_directive : enable
+
+#ifdef VULKAN
+#define VERTEX_ID gl_VertexIndex
+#else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
+#define VERTEX_ID gl_VertexID
+#endif
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+const vec2 vertices[3] =
+    vec2[3](vec2(-1,-1), vec2(3,-1), vec2(-1, 3));
+
+layout (binding = 0) uniform sampler2D input_tex;
+
+layout (location = 0) out vec2 tex_coord;
+layout (location = 1) out vec4 offset[3];
+
+vec4 metrics = vec4(1.0 / textureSize(input_tex, 0), textureSize(input_tex, 0));
+#define SMAA_RT_METRICS metrics
+#define SMAA_GLSL_4
+#define SMAA_PRESET_ULTRA
+#define SMAA_INCLUDE_VS 1
+#define SMAA_INCLUDE_PS 0
+
+#include "opengl_smaa.glsl"
+
+void main() {
+    vec2 vertex = vertices[VERTEX_ID];
+    gl_Position = vec4(vertex, 0.0, 1.0);
+    tex_coord = (vertex + 1.0) / 2.0;
+    SMAAEdgeDetectionVS(tex_coord, offset);
+}

src/video_core/host_shaders/smaa_neighborhood_blending.frag

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460
+
+#extension GL_GOOGLE_include_directive : enable
+
+layout (binding = 0) uniform sampler2D input_tex;
+layout (binding = 1) uniform sampler2D blend_tex;
+
+layout (location = 0) in vec2 tex_coord;
+layout (location = 1) in vec4 offset;
+
+layout (location = 0) out vec4 frag_color;
+
+vec4 metrics = vec4(1.0 / textureSize(input_tex, 0), textureSize(input_tex, 0));
+#define SMAA_RT_METRICS metrics
+#define SMAA_GLSL_4
+#define SMAA_PRESET_ULTRA
+#define SMAA_INCLUDE_VS 0
+#define SMAA_INCLUDE_PS 1
+
+#include "opengl_smaa.glsl"
+
+void main() {
+    frag_color = SMAANeighborhoodBlendingPS(tex_coord,
+                                  offset,
+                                  input_tex,
+                                  blend_tex
+                                  );
+}

src/video_core/host_shaders/smaa_neighborhood_blending.vert

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460
+
+#extension GL_GOOGLE_include_directive : enable
+
+#ifdef VULKAN
+#define VERTEX_ID gl_VertexIndex
+#else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
+#define VERTEX_ID gl_VertexID
+#endif
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+const vec2 vertices[3] =
+    vec2[3](vec2(-1,-1), vec2(3,-1), vec2(-1, 3));
+
+layout (binding = 0) uniform sampler2D input_tex;
+layout (binding = 1) uniform sampler2D blend_tex;
+
+layout (location = 0) out vec2 tex_coord;
+layout (location = 1) out vec4 offset;
+
+vec4 metrics = vec4(1.0 / textureSize(input_tex, 0), textureSize(input_tex, 0));
+#define SMAA_RT_METRICS metrics
+#define SMAA_GLSL_4
+#define SMAA_PRESET_ULTRA
+#define SMAA_INCLUDE_VS 1
+#define SMAA_INCLUDE_PS 0
+
+#include "opengl_smaa.glsl"
+
+void main() {
+    vec2 vertex = vertices[VERTEX_ID];
+    gl_Position = vec4(vertex, 0.0, 1.0);
+    tex_coord = (vertex + 1.0) / 2.0;
+    SMAANeighborhoodBlendingVS(tex_coord, offset);
+}

src/video_core/macro/macro_hle.cpp

@@ -5,6 +5,7 @@
 #include <vector>
 #include "common/scope_exit.h"
 #include "video_core/dirty_flags.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/macro/macro.h"
 #include "video_core/macro/macro_hle.h"
@@ -18,57 +19,33 @@ using HLEFunction = void (*)(Engines::Maxwell3D& maxwell3d, const std::vector<u3
 // HLE'd functions
 void HLE_771BB18C62444DA0(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
     const u32 instance_count = parameters[2] & maxwell3d.GetRegisterValue(0xD1B);
-
-    maxwell3d.regs.draw.topology.Assign(
-        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0] & 0x3ffffff));
-    maxwell3d.regs.global_base_instance_index = parameters[5];
-    maxwell3d.regs.global_base_vertex_index = parameters[3];
-    maxwell3d.regs.index_buffer.count = parameters[1];
-    maxwell3d.regs.index_buffer.first = parameters[4];
-
-    if (maxwell3d.ShouldExecute()) {
-        maxwell3d.Rasterizer().Draw(true, instance_count);
-    }
-    maxwell3d.regs.index_buffer.count = 0;
+    maxwell3d.draw_manager->DrawIndex(
+        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0] & 0x3ffffff),
+        parameters[4], parameters[1], parameters[3], parameters[5], instance_count);
 }
 
 void HLE_0D61FC9FAAC9FCAD(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
     const u32 instance_count = (maxwell3d.GetRegisterValue(0xD1B) & parameters[2]);
-
-    maxwell3d.regs.vertex_buffer.first = parameters[3];
-    maxwell3d.regs.vertex_buffer.count = parameters[1];
-    maxwell3d.regs.global_base_instance_index = parameters[4];
-    maxwell3d.regs.draw.topology.Assign(
-        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
-
-    if (maxwell3d.ShouldExecute()) {
-        maxwell3d.Rasterizer().Draw(false, instance_count);
-    }
-    maxwell3d.regs.vertex_buffer.count = 0;
+    maxwell3d.draw_manager->DrawArray(
+        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]),
+        parameters[3], parameters[1], parameters[4], instance_count);
 }
 
 void HLE_0217920100488FF7(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
     const u32 instance_count = (maxwell3d.GetRegisterValue(0xD1B) & parameters[2]);
     const u32 element_base = parameters[4];
     const u32 base_instance = parameters[5];
-    maxwell3d.regs.index_buffer.first = parameters[3];
     maxwell3d.regs.vertex_id_base = element_base;
-    maxwell3d.regs.index_buffer.count = parameters[1];
     maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-    maxwell3d.regs.global_base_vertex_index = element_base;
-    maxwell3d.regs.global_base_instance_index = base_instance;
     maxwell3d.CallMethod(0x8e3, 0x640, true);
     maxwell3d.CallMethod(0x8e4, element_base, true);
     maxwell3d.CallMethod(0x8e5, base_instance, true);
-    maxwell3d.regs.draw.topology.Assign(
-        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
-    if (maxwell3d.ShouldExecute()) {
-        maxwell3d.Rasterizer().Draw(true, instance_count);
-    }
+
+    maxwell3d.draw_manager->DrawIndex(
+        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]),
+        parameters[3], parameters[1], element_base, base_instance, instance_count);
+
     maxwell3d.regs.vertex_id_base = 0x0;
-    maxwell3d.regs.index_buffer.count = 0;
-    maxwell3d.regs.global_base_vertex_index = 0x0;
-    maxwell3d.regs.global_base_instance_index = 0x0;
     maxwell3d.CallMethod(0x8e3, 0x640, true);
     maxwell3d.CallMethod(0x8e4, 0x0, true);
     maxwell3d.CallMethod(0x8e5, 0x0, true);
@@ -79,9 +56,6 @@ void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
     SCOPE_EXIT({
         // Clean everything.
         maxwell3d.regs.vertex_id_base = 0x0;
-        maxwell3d.regs.index_buffer.count = 0;
-        maxwell3d.regs.global_base_vertex_index = 0x0;
-        maxwell3d.regs.global_base_instance_index = 0x0;
         maxwell3d.CallMethod(0x8e3, 0x640, true);
         maxwell3d.CallMethod(0x8e4, 0x0, true);
         maxwell3d.CallMethod(0x8e5, 0x0, true);
@@ -93,9 +67,6 @@ void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
         // Nothing to do.
         return;
     }
-    const auto topology =
-        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[2]);
-    maxwell3d.regs.draw.topology.Assign(topology);
     const u32 padding = parameters[3];
     const std::size_t max_draws = parameters[4];
 
@@ -106,23 +77,17 @@ void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
 
     for (std::size_t index = first_draw; index < last_draw; index++) {
         const std::size_t base = index * indirect_words + 5;
-        const u32 num_vertices = parameters[base];
-        const u32 instance_count = parameters[base + 1];
-        const u32 first_index = parameters[base + 2];
         const u32 base_vertex = parameters[base + 3];
         const u32 base_instance = parameters[base + 4];
-        maxwell3d.regs.index_buffer.first = first_index;
         maxwell3d.regs.vertex_id_base = base_vertex;
-        maxwell3d.regs.index_buffer.count = num_vertices;
-        maxwell3d.regs.global_base_vertex_index = base_vertex;
-        maxwell3d.regs.global_base_instance_index = base_instance;
         maxwell3d.CallMethod(0x8e3, 0x640, true);
         maxwell3d.CallMethod(0x8e4, base_vertex, true);
         maxwell3d.CallMethod(0x8e5, base_instance, true);
         maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-        if (maxwell3d.ShouldExecute()) {
-            maxwell3d.Rasterizer().Draw(true, instance_count);
-        }
+        maxwell3d.draw_manager->DrawIndex(
+            static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[2]),
+            parameters[base + 2], parameters[base], base_vertex, base_instance,
+            parameters[base + 1]);
     }
 }
 
@@ -136,7 +101,7 @@ void HLE_EAD26C3E2109B06B(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
     ASSERT(clear_params.layer == 0);
 
     maxwell3d.regs.clear_surface.raw = clear_params.raw;
-    maxwell3d.ProcessClearBuffers(num_layers);
+    maxwell3d.draw_manager->Clear(num_layers);
 }
 
 constexpr std::array<std::pair<u64, HLEFunction>, 5> hle_funcs{{

src/video_core/renderer_opengl/gl_device.cpp

@@ -112,7 +112,7 @@ bool IsASTCSupported() {
 }
 } // Anonymous namespace
 
-Device::Device() {
+Device::Device(Core::Frontend::EmuWindow& emu_window) {
     if (!GLAD_GL_VERSION_4_6) {
         LOG_ERROR(Render_OpenGL, "OpenGL 4.6 is not available");
         throw std::runtime_error{"Insufficient version"};
@@ -126,9 +126,9 @@ Device::Device() {
     const bool is_intel = vendor_name == "Intel";
 
 #ifdef __unix__
-    const bool is_linux = true;
+    constexpr bool is_linux = true;
 #else
-    const bool is_linux = false;
+    constexpr bool is_linux = false;
 #endif
 
     bool disable_fast_buffer_sub_data = false;
@@ -193,9 +193,11 @@ Device::Device() {
         }
     }
 
+    strict_context_required = emu_window.StrictContextRequired();
     // Blocks AMD and Intel OpenGL drivers on Windows from using asynchronous shader compilation.
+    // Blocks EGL on Wayland from using asynchronous shader compilation.
     use_asynchronous_shaders = Settings::values.use_asynchronous_shaders.GetValue() &&
-                               !(is_amd || (is_intel && !is_linux));
+                               !(is_amd || (is_intel && !is_linux)) && !strict_context_required;
     use_driver_cache = is_nvidia;
 
     LOG_INFO(Render_OpenGL, "Renderer_VariableAOFFI: {}", has_variable_aoffi);

src/video_core/renderer_opengl/gl_device.h

@@ -5,6 +5,7 @@
 
 #include <cstddef>
 #include "common/common_types.h"
+#include "core/frontend/emu_window.h"
 #include "shader_recompiler/stage.h"
 
 namespace Settings {
@@ -15,7 +16,7 @@ namespace OpenGL {
 
 class Device {
 public:
-    explicit Device();
+    explicit Device(Core::Frontend::EmuWindow& emu_window);
 
     [[nodiscard]] std::string GetVendorName() const;
 
@@ -173,6 +174,10 @@ public:
         return can_report_memory;
     }
 
+    bool StrictContextRequired() const {
+        return strict_context_required;
+    }
+
 private:
     static bool TestVariableAoffi();
     static bool TestPreciseBug();
@@ -216,6 +221,7 @@ private:
     bool has_cbuf_ftou_bug{};
     bool has_bool_ref_bug{};
     bool can_report_memory{};
+    bool strict_context_required{};
 
     std::string vendor_name;
 };

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -138,9 +138,6 @@ void RasterizerOpenGL::LoadDiskResources(u64 title_id, std::stop_token stop_load
 
 void RasterizerOpenGL::Clear(u32 layer_count) {
     MICROPROFILE_SCOPE(OpenGL_Clears);
-    if (!maxwell3d->ShouldExecute()) {
-        return;
-    }
 
     const auto& regs = maxwell3d->regs;
     bool use_color{};
@@ -224,16 +221,18 @@ void RasterizerOpenGL::Draw(bool is_indexed, u32 instance_count) {
 
     SyncState();
 
-    const GLenum primitive_mode = MaxwellToGL::PrimitiveTopology(maxwell3d->regs.draw.topology);
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+
+    const GLenum primitive_mode = MaxwellToGL::PrimitiveTopology(draw_state.topology);
     BeginTransformFeedback(pipeline, primitive_mode);
 
-    const GLuint base_instance = static_cast<GLuint>(maxwell3d->regs.global_base_instance_index);
+    const GLuint base_instance = static_cast<GLuint>(draw_state.base_instance);
     const GLsizei num_instances = static_cast<GLsizei>(instance_count);
     if (is_indexed) {
-        const GLint base_vertex = static_cast<GLint>(maxwell3d->regs.global_base_vertex_index);
-        const GLsizei num_vertices = static_cast<GLsizei>(maxwell3d->regs.index_buffer.count);
+        const GLint base_vertex = static_cast<GLint>(draw_state.base_index);
+        const GLsizei num_vertices = static_cast<GLsizei>(draw_state.index_buffer.count);
         const GLvoid* const offset = buffer_cache_runtime.IndexOffset();
-        const GLenum format = MaxwellToGL::IndexFormat(maxwell3d->regs.index_buffer.format);
+        const GLenum format = MaxwellToGL::IndexFormat(draw_state.index_buffer.format);
         if (num_instances == 1 && base_instance == 0 && base_vertex == 0) {
             glDrawElements(primitive_mode, num_vertices, format, offset);
         } else if (num_instances == 1 && base_instance == 0) {
@@ -252,8 +251,8 @@ void RasterizerOpenGL::Draw(bool is_indexed, u32 instance_count) {
                                                           base_instance);
         }
     } else {
-        const GLint base_vertex = static_cast<GLint>(maxwell3d->regs.vertex_buffer.first);
-        const GLsizei num_vertices = static_cast<GLsizei>(maxwell3d->regs.vertex_buffer.count);
+        const GLint base_vertex = static_cast<GLint>(draw_state.vertex_buffer.first);
+        const GLsizei num_vertices = static_cast<GLsizei>(draw_state.vertex_buffer.count);
         if (num_instances == 1 && base_instance == 0) {
             glDrawArrays(primitive_mode, base_vertex, num_vertices);
         } else if (base_instance == 0) {

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -22,6 +22,7 @@
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
 #include "shader_recompiler/frontend/maxwell/translate_program.h"
 #include "shader_recompiler/profile.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/memory_manager.h"
@@ -173,6 +174,7 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
       texture_cache{texture_cache_}, buffer_cache{buffer_cache_}, program_manager{program_manager_},
       state_tracker{state_tracker_}, shader_notify{shader_notify_},
       use_asynchronous_shaders{device.UseAsynchronousShaders()},
+      strict_context_required{device.StrictContextRequired()},
       profile{
           .supported_spirv = 0x00010000,
 
@@ -254,9 +256,14 @@ void ShaderCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
     }
     shader_cache_filename = base_dir / "opengl.bin";
 
-    if (!workers) {
+    if (!workers && !strict_context_required) {
         workers = CreateWorkers();
     }
+    std::optional<Context> strict_context;
+    if (strict_context_required) {
+        strict_context.emplace(emu_window);
+    }
+
     struct {
         std::mutex mutex;
         size_t total{};
@@ -264,44 +271,49 @@ void ShaderCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
         bool has_loaded{};
     } state;
 
+    const auto queue_work{[&](Common::UniqueFunction<void, Context*>&& work) {
+        if (strict_context_required) {
+            work(&strict_context.value());
+        } else {
+            workers->QueueWork(std::move(work));
+        }
+    }};
     const auto load_compute{[&](std::ifstream& file, FileEnvironment env) {
         ComputePipelineKey key;
         file.read(reinterpret_cast<char*>(&key), sizeof(key));
-        workers->QueueWork(
-            [this, key, env = std::move(env), &state, &callback](Context* ctx) mutable {
-                ctx->pools.ReleaseContents();
-                auto pipeline{CreateComputePipeline(ctx->pools, key, env)};
-                std::scoped_lock lock{state.mutex};
-                if (pipeline) {
-                    compute_cache.emplace(key, std::move(pipeline));
-                }
-                ++state.built;
-                if (state.has_loaded) {
-                    callback(VideoCore::LoadCallbackStage::Build, state.built, state.total);
-                }
-            });
+        queue_work([this, key, env = std::move(env), &state, &callback](Context* ctx) mutable {
+            ctx->pools.ReleaseContents();
+            auto pipeline{CreateComputePipeline(ctx->pools, key, env)};
+            std::scoped_lock lock{state.mutex};
+            if (pipeline) {
+                compute_cache.emplace(key, std::move(pipeline));
+            }
+            ++state.built;
+            if (state.has_loaded) {
+                callback(VideoCore::LoadCallbackStage::Build, state.built, state.total);
+            }
+        });
         ++state.total;
     }};
     const auto load_graphics{[&](std::ifstream& file, std::vector<FileEnvironment> envs) {
         GraphicsPipelineKey key;
         file.read(reinterpret_cast<char*>(&key), sizeof(key));
-        workers->QueueWork(
-            [this, key, envs = std::move(envs), &state, &callback](Context* ctx) mutable {
-                boost::container::static_vector<Shader::Environment*, 5> env_ptrs;
-                for (auto& env : envs) {
-                    env_ptrs.push_back(&env);
-                }
-                ctx->pools.ReleaseContents();
-                auto pipeline{CreateGraphicsPipeline(ctx->pools, key, MakeSpan(env_ptrs), false)};
-                std::scoped_lock lock{state.mutex};
-                if (pipeline) {
-                    graphics_cache.emplace(key, std::move(pipeline));
-                }
-                ++state.built;
-                if (state.has_loaded) {
-                    callback(VideoCore::LoadCallbackStage::Build, state.built, state.total);
-                }
-            });
+        queue_work([this, key, envs = std::move(envs), &state, &callback](Context* ctx) mutable {
+            boost::container::static_vector<Shader::Environment*, 5> env_ptrs;
+            for (auto& env : envs) {
+                env_ptrs.push_back(&env);
+            }
+            ctx->pools.ReleaseContents();
+            auto pipeline{CreateGraphicsPipeline(ctx->pools, key, MakeSpan(env_ptrs), false)};
+            std::scoped_lock lock{state.mutex};
+            if (pipeline) {
+                graphics_cache.emplace(key, std::move(pipeline));
+            }
+            ++state.built;
+            if (state.has_loaded) {
+                callback(VideoCore::LoadCallbackStage::Build, state.built, state.total);
+            }
+        });
         ++state.total;
     }};
     LoadPipelines(stop_loading, shader_cache_filename, CACHE_VERSION, load_compute, load_graphics);
@@ -313,6 +325,9 @@ void ShaderCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
     state.has_loaded = true;
     lock.unlock();
 
+    if (strict_context_required) {
+        return;
+    }
     workers->WaitForRequests(stop_loading);
     if (!use_asynchronous_shaders) {
         workers.reset();
@@ -327,7 +342,7 @@ GraphicsPipeline* ShaderCache::CurrentGraphicsPipeline() {
     const auto& regs{maxwell3d->regs};
     graphics_key.raw = 0;
     graphics_key.early_z.Assign(regs.mandated_early_z != 0 ? 1 : 0);
-    graphics_key.gs_input_topology.Assign(regs.draw.topology.Value());
+    graphics_key.gs_input_topology.Assign(maxwell3d->draw_manager->GetDrawState().topology);
     graphics_key.tessellation_primitive.Assign(regs.tessellation.params.domain_type.Value());
     graphics_key.tessellation_spacing.Assign(regs.tessellation.params.spacing.Value());
     graphics_key.tessellation_clockwise.Assign(
@@ -371,7 +386,8 @@ GraphicsPipeline* ShaderCache::BuiltPipeline(GraphicsPipeline* pipeline) const n
     // If games are using a small index count, we can assume these are full screen quads.
     // Usually these shaders are only used once for building textures so we can assume they
     // can't be built async
-    if (maxwell3d->regs.index_buffer.count <= 6 || maxwell3d->regs.vertex_buffer.count <= 6) {
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+    if (draw_state.index_buffer.count <= 6 || draw_state.vertex_buffer.count <= 6) {
         return pipeline;
     }
     return nullptr;

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -69,6 +69,7 @@ private:
     StateTracker& state_tracker;
     VideoCore::ShaderNotify& shader_notify;
     const bool use_asynchronous_shaders;
+    const bool strict_context_required;
 
     GraphicsPipelineKey graphics_key{};
     GraphicsPipeline* current_pipeline{};

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -22,12 +22,21 @@
 #include "video_core/host_shaders/opengl_present_frag.h"
 #include "video_core/host_shaders/opengl_present_scaleforce_frag.h"
 #include "video_core/host_shaders/opengl_present_vert.h"
+#include "video_core/host_shaders/opengl_smaa_glsl.h"
 #include "video_core/host_shaders/present_bicubic_frag.h"
 #include "video_core/host_shaders/present_gaussian_frag.h"
+#include "video_core/host_shaders/smaa_blending_weight_calculation_frag.h"
+#include "video_core/host_shaders/smaa_blending_weight_calculation_vert.h"
+#include "video_core/host_shaders/smaa_edge_detection_frag.h"
+#include "video_core/host_shaders/smaa_edge_detection_vert.h"
+#include "video_core/host_shaders/smaa_neighborhood_blending_frag.h"
+#include "video_core/host_shaders/smaa_neighborhood_blending_vert.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
+#include "video_core/smaa_area_tex.h"
+#include "video_core/smaa_search_tex.h"
 #include "video_core/textures/decoders.h"
 
 namespace OpenGL {
@@ -131,8 +140,8 @@ RendererOpenGL::RendererOpenGL(Core::TelemetrySession& telemetry_session_,
                                Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
                                std::unique_ptr<Core::Frontend::GraphicsContext> context_)
     : RendererBase{emu_window_, std::move(context_)}, telemetry_session{telemetry_session_},
-      emu_window{emu_window_}, cpu_memory{cpu_memory_}, gpu{gpu_}, state_tracker{},
-      program_manager{device},
+      emu_window{emu_window_}, cpu_memory{cpu_memory_}, gpu{gpu_}, device{emu_window_},
+      state_tracker{}, program_manager{device},
       rasterizer(emu_window, gpu, cpu_memory, device, screen_info, program_manager, state_tracker) {
     if (Settings::values.renderer_debug && GLAD_GL_KHR_debug) {
         glEnable(GL_DEBUG_OUTPUT);
@@ -258,6 +267,28 @@ void RendererOpenGL::InitOpenGLObjects() {
     // Create shader programs
     fxaa_vertex = CreateProgram(HostShaders::FXAA_VERT, GL_VERTEX_SHADER);
     fxaa_fragment = CreateProgram(HostShaders::FXAA_FRAG, GL_FRAGMENT_SHADER);
+
+    const auto SmaaShader = [](std::string_view specialized_source, GLenum stage) {
+        std::string shader_source{specialized_source};
+        constexpr std::string_view include_string = "#include \"opengl_smaa.glsl\"";
+        const std::size_t pos = shader_source.find(include_string);
+        ASSERT(pos != std::string::npos);
+        shader_source.replace(pos, include_string.size(), HostShaders::OPENGL_SMAA_GLSL);
+        return CreateProgram(shader_source, stage);
+    };
+
+    smaa_edge_detection_vert = SmaaShader(HostShaders::SMAA_EDGE_DETECTION_VERT, GL_VERTEX_SHADER);
+    smaa_edge_detection_frag =
+        SmaaShader(HostShaders::SMAA_EDGE_DETECTION_FRAG, GL_FRAGMENT_SHADER);
+    smaa_blending_weight_calculation_vert =
+        SmaaShader(HostShaders::SMAA_BLENDING_WEIGHT_CALCULATION_VERT, GL_VERTEX_SHADER);
+    smaa_blending_weight_calculation_frag =
+        SmaaShader(HostShaders::SMAA_BLENDING_WEIGHT_CALCULATION_FRAG, GL_FRAGMENT_SHADER);
+    smaa_neighborhood_blending_vert =
+        SmaaShader(HostShaders::SMAA_NEIGHBORHOOD_BLENDING_VERT, GL_VERTEX_SHADER);
+    smaa_neighborhood_blending_frag =
+        SmaaShader(HostShaders::SMAA_NEIGHBORHOOD_BLENDING_FRAG, GL_FRAGMENT_SHADER);
+
     present_vertex = CreateProgram(HostShaders::OPENGL_PRESENT_VERT, GL_VERTEX_SHADER);
     present_bilinear_fragment = CreateProgram(HostShaders::OPENGL_PRESENT_FRAG, GL_FRAGMENT_SHADER);
     present_bicubic_fragment = CreateProgram(HostShaders::PRESENT_BICUBIC_FRAG, GL_FRAGMENT_SHADER);
@@ -293,7 +324,16 @@ void RendererOpenGL::InitOpenGLObjects() {
     // Clear screen to black
     LoadColorToActiveGLTexture(0, 0, 0, 0, screen_info.texture);
 
-    fxaa_framebuffer.Create();
+    aa_framebuffer.Create();
+
+    smaa_area_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(smaa_area_tex.handle, 1, GL_RG8, AREATEX_WIDTH, AREATEX_HEIGHT);
+    glTextureSubImage2D(smaa_area_tex.handle, 0, 0, 0, AREATEX_WIDTH, AREATEX_HEIGHT, GL_RG,
+                        GL_UNSIGNED_BYTE, areaTexBytes);
+    smaa_search_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(smaa_search_tex.handle, 1, GL_R8, SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT);
+    glTextureSubImage2D(smaa_search_tex.handle, 0, 0, 0, SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT, GL_RED,
+                        GL_UNSIGNED_BYTE, searchTexBytes);
 }
 
 void RendererOpenGL::AddTelemetryFields() {
@@ -346,13 +386,22 @@ void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
     texture.resource.Release();
     texture.resource.Create(GL_TEXTURE_2D);
     glTextureStorage2D(texture.resource.handle, 1, internal_format, texture.width, texture.height);
-    fxaa_texture.Release();
-    fxaa_texture.Create(GL_TEXTURE_2D);
-    glTextureStorage2D(fxaa_texture.handle, 1, GL_RGBA16F,
+    aa_texture.Release();
+    aa_texture.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(aa_texture.handle, 1, GL_RGBA16F,
+                       Settings::values.resolution_info.ScaleUp(screen_info.texture.width),
+                       Settings::values.resolution_info.ScaleUp(screen_info.texture.height));
+    glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0, aa_texture.handle, 0);
+    smaa_edges_tex.Release();
+    smaa_edges_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(smaa_edges_tex.handle, 1, GL_RG16F,
+                       Settings::values.resolution_info.ScaleUp(screen_info.texture.width),
+                       Settings::values.resolution_info.ScaleUp(screen_info.texture.height));
+    smaa_blend_tex.Release();
+    smaa_blend_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(smaa_blend_tex.handle, 1, GL_RGBA16F,
                        Settings::values.resolution_info.ScaleUp(screen_info.texture.width),
                        Settings::values.resolution_info.ScaleUp(screen_info.texture.height));
-    glNamedFramebufferTexture(fxaa_framebuffer.handle, GL_COLOR_ATTACHMENT0, fxaa_texture.handle,
-                              0);
 }
 
 void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
@@ -377,11 +426,6 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
 
     state_tracker.ClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
 
-    // Update background color before drawing
-    glClearColor(Settings::values.bg_red.GetValue() / 255.0f,
-                 Settings::values.bg_green.GetValue() / 255.0f,
-                 Settings::values.bg_blue.GetValue() / 255.0f, 1.0f);
-
     glEnable(GL_CULL_FACE);
     glDisable(GL_COLOR_LOGIC_OP);
     glDisable(GL_DEPTH_TEST);
@@ -394,12 +438,12 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
     glCullFace(GL_BACK);
     glFrontFace(GL_CW);
     glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glDepthRangeIndexed(0, 0.0, 0.0);
 
     glBindTextureUnit(0, screen_info.display_texture);
 
-    if (Settings::values.anti_aliasing.GetValue() == Settings::AntiAliasing::Fxaa) {
-        program_manager.BindPresentPrograms(fxaa_vertex.handle, fxaa_fragment.handle);
-
+    const auto anti_aliasing = Settings::values.anti_aliasing.GetValue();
+    if (anti_aliasing != Settings::AntiAliasing::None) {
         glEnablei(GL_SCISSOR_TEST, 0);
         auto viewport_width = screen_info.texture.width;
         auto scissor_width = framebuffer_crop_rect.GetWidth();
@@ -420,21 +464,60 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
         glScissorIndexed(0, 0, 0, scissor_width, scissor_height);
         glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(viewport_width),
                            static_cast<GLfloat>(viewport_height));
-        glDepthRangeIndexed(0, 0.0, 0.0);
 
         glBindSampler(0, present_sampler.handle);
         GLint old_read_fb;
         GLint old_draw_fb;
         glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &old_read_fb);
         glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &old_draw_fb);
-        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fxaa_framebuffer.handle);
 
-        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+        switch (anti_aliasing) {
+        case Settings::AntiAliasing::Fxaa: {
+            program_manager.BindPresentPrograms(fxaa_vertex.handle, fxaa_fragment.handle);
+            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, aa_framebuffer.handle);
+            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+        } break;
+        case Settings::AntiAliasing::Smaa: {
+            glClearColor(0, 0, 0, 0);
+            glFrontFace(GL_CCW);
+            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, aa_framebuffer.handle);
+            glBindSampler(1, present_sampler.handle);
+            glBindSampler(2, present_sampler.handle);
+
+            glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0,
+                                      smaa_edges_tex.handle, 0);
+            glClear(GL_COLOR_BUFFER_BIT);
+            program_manager.BindPresentPrograms(smaa_edge_detection_vert.handle,
+                                                smaa_edge_detection_frag.handle);
+            glDrawArrays(GL_TRIANGLES, 0, 3);
+
+            glBindTextureUnit(0, smaa_edges_tex.handle);
+            glBindTextureUnit(1, smaa_area_tex.handle);
+            glBindTextureUnit(2, smaa_search_tex.handle);
+            glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0,
+                                      smaa_blend_tex.handle, 0);
+            glClear(GL_COLOR_BUFFER_BIT);
+            program_manager.BindPresentPrograms(smaa_blending_weight_calculation_vert.handle,
+                                                smaa_blending_weight_calculation_frag.handle);
+            glDrawArrays(GL_TRIANGLES, 0, 3);
+
+            glBindTextureUnit(0, screen_info.display_texture);
+            glBindTextureUnit(1, smaa_blend_tex.handle);
+            glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0,
+                                      aa_texture.handle, 0);
+            program_manager.BindPresentPrograms(smaa_neighborhood_blending_vert.handle,
+                                                smaa_neighborhood_blending_frag.handle);
+            glDrawArrays(GL_TRIANGLES, 0, 3);
+            glFrontFace(GL_CW);
+        } break;
+        default:
+            UNREACHABLE();
+        }
 
         glBindFramebuffer(GL_READ_FRAMEBUFFER, old_read_fb);
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, old_draw_fb);
 
-        glBindTextureUnit(0, fxaa_texture.handle);
+        glBindTextureUnit(0, aa_texture.handle);
     }
     const std::array ortho_matrix =
         MakeOrthographicMatrix(static_cast<float>(layout.width), static_cast<float>(layout.height));
@@ -551,6 +634,11 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
         glBindSampler(0, present_sampler_nn.handle);
     }
 
+    // Update background color before drawing
+    glClearColor(Settings::values.bg_red.GetValue() / 255.0f,
+                 Settings::values.bg_green.GetValue() / 255.0f,
+                 Settings::values.bg_blue.GetValue() / 255.0f, 1.0f);
+
     glClear(GL_COLOR_BUFFER_BIT);
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 

src/video_core/renderer_opengl/renderer_opengl.h

@@ -127,8 +127,19 @@ private:
 
     /// Display information for Switch screen
     ScreenInfo screen_info;
-    OGLTexture fxaa_texture;
-    OGLFramebuffer fxaa_framebuffer;
+    OGLTexture aa_texture;
+    OGLFramebuffer aa_framebuffer;
+
+    OGLProgram smaa_edge_detection_vert;
+    OGLProgram smaa_blending_weight_calculation_vert;
+    OGLProgram smaa_neighborhood_blending_vert;
+    OGLProgram smaa_edge_detection_frag;
+    OGLProgram smaa_blending_weight_calculation_frag;
+    OGLProgram smaa_neighborhood_blending_frag;
+    OGLTexture smaa_area_tex;
+    OGLTexture smaa_search_tex;
+    OGLTexture smaa_edges_tex;
+    OGLTexture smaa_blend_tex;
 
     /// OpenGL framebuffer data
     std::vector<u8> gl_framebuffer_data;

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -8,6 +8,7 @@
 #include "common/cityhash.h"
 #include "common/common_types.h"
 #include "common/polyfill_ranges.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 
@@ -50,12 +51,13 @@ void RefreshXfbState(VideoCommon::TransformFeedbackState& state, const Maxwell&
 void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d,
                                  bool has_extended_dynamic_state, bool has_dynamic_vertex_input) {
     const Maxwell& regs = maxwell3d.regs;
+    const auto topology_ = maxwell3d.draw_manager->GetDrawState().topology;
     const std::array enabled_lut{
         regs.polygon_offset_point_enable,
         regs.polygon_offset_line_enable,
         regs.polygon_offset_fill_enable,
     };
-    const u32 topology_index = static_cast<u32>(regs.draw.topology.Value());
+    const u32 topology_index = static_cast<u32>(topology_);
 
     raw1 = 0;
     extended_dynamic_state.Assign(has_extended_dynamic_state ? 1 : 0);
@@ -78,7 +80,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d,
                                   Maxwell::Tessellation::OutputPrimitives::Triangles_CW);
     logic_op_enable.Assign(regs.logic_op.enable != 0 ? 1 : 0);
     logic_op.Assign(PackLogicOp(regs.logic_op.op));
-    topology.Assign(regs.draw.topology);
+    topology.Assign(topology_);
     msaa_mode.Assign(regs.anti_alias_samples_mode);
 
     raw2 = 0;

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -139,23 +139,25 @@ void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
     RenderScreenshot(*framebuffer, use_accelerated);
 
     bool has_been_recreated = false;
-    const auto recreate_swapchain = [&] {
+    const auto recreate_swapchain = [&](u32 width, u32 height) {
         if (!has_been_recreated) {
             has_been_recreated = true;
             scheduler.Finish();
         }
-        const Layout::FramebufferLayout layout = render_window.GetFramebufferLayout();
-        swapchain.Create(layout.width, layout.height, is_srgb);
+        swapchain.Create(width, height, is_srgb);
     };
-    if (swapchain.NeedsRecreation(is_srgb)) {
-        recreate_swapchain();
+
+    const Layout::FramebufferLayout layout = render_window.GetFramebufferLayout();
+    if (swapchain.NeedsRecreation(is_srgb) || swapchain.GetWidth() != layout.width ||
+        swapchain.GetHeight() != layout.height) {
+        recreate_swapchain(layout.width, layout.height);
     }
     bool is_outdated;
     do {
         swapchain.AcquireNextImage();
         is_outdated = swapchain.IsOutDated();
         if (is_outdated) {
-            recreate_swapchain();
+            recreate_swapchain(layout.width, layout.height);
         }
     } while (is_outdated);
     if (has_been_recreated) {

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -29,6 +29,7 @@
 #include "video_core/renderer_vulkan/vk_fsr.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_shader_util.h"
+#include "video_core/renderer_vulkan/vk_smaa.h"
 #include "video_core/renderer_vulkan/vk_swapchain.h"
 #include "video_core/surface.h"
 #include "video_core/textures/decoders.h"
@@ -156,6 +157,7 @@ VkSemaphore BlitScreen::Draw(const Tegra::FramebufferConfig& framebuffer,
     scheduler.Wait(resource_ticks[image_index]);
     resource_ticks[image_index] = scheduler.CurrentTick();
 
+    VkImage source_image = use_accelerated ? screen_info.image : *raw_images[image_index];
     VkImageView source_image_view =
         use_accelerated ? screen_info.image_view : *raw_image_views[image_index];
 
@@ -242,7 +244,7 @@ VkSemaphore BlitScreen::Draw(const Tegra::FramebufferConfig& framebuffer,
     }
 
     const auto anti_alias_pass = Settings::values.anti_aliasing.GetValue();
-    if (use_accelerated && anti_alias_pass != Settings::AntiAliasing::None) {
+    if (use_accelerated && anti_alias_pass == Settings::AntiAliasing::Fxaa) {
         UpdateAADescriptorSet(image_index, source_image_view, false);
         const u32 up_scale = Settings::values.resolution_info.up_scale;
         const u32 down_shift = Settings::values.resolution_info.down_shift;
@@ -340,7 +342,18 @@ VkSemaphore BlitScreen::Draw(const Tegra::FramebufferConfig& framebuffer,
         });
         source_image_view = *aa_image_view;
     }
-
+    if (use_accelerated && anti_alias_pass == Settings::AntiAliasing::Smaa) {
+        if (!smaa) {
+            const u32 up_scale = Settings::values.resolution_info.up_scale;
+            const u32 down_shift = Settings::values.resolution_info.down_shift;
+            const VkExtent2D smaa_size{
+                .width = (up_scale * framebuffer.width) >> down_shift,
+                .height = (up_scale * framebuffer.height) >> down_shift,
+            };
+            CreateSMAA(smaa_size);
+        }
+        source_image_view = smaa->Draw(scheduler, image_index, source_image, source_image_view);
+    }
     if (fsr) {
         auto crop_rect = framebuffer.crop_rect;
         if (crop_rect.GetWidth() == 0) {
@@ -467,6 +480,7 @@ void BlitScreen::CreateDynamicResources() {
     CreateFramebuffers();
     CreateGraphicsPipeline();
     fsr.reset();
+    smaa.reset();
     if (Settings::values.scaling_filter.GetValue() == Settings::ScalingFilter::Fsr) {
         CreateFSR();
     }
@@ -490,6 +504,7 @@ void BlitScreen::RefreshResources(const Tegra::FramebufferConfig& framebuffer) {
     raw_height = framebuffer.height;
     pixel_format = framebuffer.pixel_format;
 
+    smaa.reset();
     ReleaseRawImages();
 
     CreateStagingBuffer(framebuffer);
@@ -1448,6 +1463,10 @@ void BlitScreen::SetVertexData(BufferData& data, const Tegra::FramebufferConfig&
         ScreenRectVertex(x + w, y + h, texcoords.bottom * scale_u, left_start + right * scale_v);
 }
 
+void BlitScreen::CreateSMAA(VkExtent2D smaa_size) {
+    smaa = std::make_unique<SMAA>(device, memory_allocator, image_count, smaa_size);
+}
+
 void BlitScreen::CreateFSR() {
     const auto& layout = render_window.GetFramebufferLayout();
     const VkExtent2D fsr_size{

src/video_core/renderer_vulkan/vk_blit_screen.h

@@ -40,9 +40,11 @@ class Device;
 class FSR;
 class RasterizerVulkan;
 class Scheduler;
+class SMAA;
 class Swapchain;
 
 struct ScreenInfo {
+    VkImage image{};
     VkImageView image_view{};
     u32 width{};
     u32 height{};
@@ -101,6 +103,7 @@ private:
     void SetVertexData(BufferData& data, const Tegra::FramebufferConfig& framebuffer,
                        const Layout::FramebufferLayout layout) const;
 
+    void CreateSMAA(VkExtent2D smaa_size);
     void CreateFSR();
 
     u64 CalculateBufferSize(const Tegra::FramebufferConfig& framebuffer) const;
@@ -163,6 +166,7 @@ private:
     Service::android::PixelFormat pixel_format{};
 
     std::unique_ptr<FSR> fsr;
+    std::unique_ptr<SMAA> smaa;
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -285,6 +285,9 @@ void BufferCacheRuntime::BindQuadArrayIndexBuffer(u32 first, u32 count) {
 
 void BufferCacheRuntime::BindVertexBuffer(u32 index, VkBuffer buffer, u32 offset, u32 size,
                                           u32 stride) {
+    if (index >= device.GetMaxVertexInputBindings()) {
+        return;
+    }
     if (device.IsExtExtendedDynamicStateSupported()) {
         scheduler.Record([index, buffer, offset, size, stride](vk::CommandBuffer cmdbuf) {
             const VkDeviceSize vk_offset = buffer != VK_NULL_HANDLE ? offset : 0;

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -529,7 +529,9 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
     static_vector<VkVertexInputBindingDivisorDescriptionEXT, 32> vertex_binding_divisors;
     static_vector<VkVertexInputAttributeDescription, 32> vertex_attributes;
     if (key.state.dynamic_vertex_input) {
-        for (size_t index = 0; index < key.state.attributes.size(); ++index) {
+        const size_t num_vertex_arrays = std::min(
+            key.state.attributes.size(), static_cast<size_t>(device.GetMaxVertexInputBindings()));
+        for (size_t index = 0; index < num_vertex_arrays; ++index) {
             const u32 type = key.state.DynamicAttributeType(index);
             if (!stage_infos[0].loads.Generic(index) || type == 0) {
                 continue;
@@ -551,7 +553,9 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
             });
         }
     } else {
-        for (size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
+        const size_t num_vertex_arrays = std::min(
+            Maxwell::NumVertexArrays, static_cast<size_t>(device.GetMaxVertexInputBindings()));
+        for (size_t index = 0; index < num_vertex_arrays; ++index) {
             const bool instanced = key.state.binding_divisors[index] != 0;
             const auto rate =
                 instanced ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX;
@@ -580,6 +584,8 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
             });
         }
     }
+    ASSERT(vertex_attributes.size() <= device.GetMaxVertexInputAttributes());
+
     VkPipelineVertexInputStateCreateInfo vertex_input_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .pNext = nullptr,