time: add LockFreeAtomicType

EmuThread: refactor

.ci/scripts/clang/docker.sh

@@ -11,6 +11,7 @@ ccache -s
 mkdir build || true && cd build
 cmake .. \
       -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_CXX_FLAGS="-march=x86-64-v2" \
       -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ \
       -DCMAKE_C_COMPILER=/usr/lib/ccache/clang \
       -DCMAKE_INSTALL_PREFIX="/usr" \

.ci/scripts/linux/docker.sh

@@ -12,6 +12,7 @@ mkdir build || true && cd build
 cmake .. \
       -DBoost_USE_STATIC_LIBS=ON \
       -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_CXX_FLAGS="-march=x86-64-v2" \
       -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ \
       -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc \
       -DCMAKE_INSTALL_PREFIX="/usr" \

.ci/templates/build-msvc.yml

@@ -9,7 +9,7 @@ parameters:
 steps:
 - script: choco install vulkan-sdk
   displayName: 'Install vulkan-sdk'
-- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 17 2022" -A x64 -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
+- script: refreshenv && mkdir build && cd build && cmake -E env CXXFLAGS="/Gw /GA /Gr /Ob2" cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
   displayName: 'Configure CMake'
 - task: MSBuild@1
   displayName: 'Build'

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/")
@@ -51,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")
@@ -204,7 +208,7 @@ find_package(libusb 1.0.24)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
 find_package(Opus 1.3)
-find_package(Vulkan 1.3.213)
+find_package(Vulkan 1.3.238)
 find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)
 
@@ -579,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/find-modules/FindOpus.cmake

@@ -2,9 +2,7 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)
-endif()
+pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Opus

externals/find-modules/Findenet.cmake

@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(ENET QUIET IMPORTED_TARGET libenet)
-endif()
+pkg_search_module(ENET QUIET IMPORTED_TARGET libenet)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(enet

externals/find-modules/Findhttplib.cmake

@@ -9,9 +9,7 @@ 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 cpp-httplib)
-    endif()
+    pkg_search_module(HTTPLIB QUIET IMPORTED_TARGET cpp-httplib)
     find_package_handle_standard_args(httplib
         REQUIRED_VARS HTTPLIB_INCLUDEDIR
         VERSION_VAR HTTPLIB_VERSION

externals/find-modules/Findinih.cmake

@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)
-endif()
+pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(inih

externals/find-modules/Findlibusb.cmake

@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(LIBUSB QUIET IMPORTED_TARGET libusb-1.0)
-endif()
+pkg_search_module(LIBUSB QUIET IMPORTED_TARGET libusb-1.0)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(libusb

externals/find-modules/Findlz4.cmake

@@ -8,9 +8,7 @@ if (lz4_FOUND)
     find_package_handle_standard_args(lz4 CONFIG_MODE)
 else()
     find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(LZ4 QUIET IMPORTED_TARGET liblz4)
-    endif()
+    pkg_search_module(LZ4 QUIET IMPORTED_TARGET liblz4)
     find_package_handle_standard_args(lz4
         REQUIRED_VARS LZ4_LINK_LIBRARIES
         VERSION_VAR LZ4_VERSION

externals/find-modules/Findzstd.cmake

@@ -8,9 +8,7 @@ if (zstd_FOUND)
     find_package_handle_standard_args(zstd CONFIG_MODE)
 else()
     find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
-    endif()
+    pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
     find_package_handle_standard_args(zstd
         REQUIRED_VARS ZSTD_LINK_LIBRARIES
         VERSION_VAR ZSTD_VERSION

src/audio_core/device/audio_buffers.h

@@ -91,9 +91,10 @@ public:
      * @param core_timing - The CoreTiming instance
      * @param session     - The device session
      *
-     * @return Is the buffer was released.
+     * @return If any buffer was released.
      */
-    bool ReleaseBuffers(const Core::Timing::CoreTiming& core_timing, const DeviceSession& session) {
+    bool ReleaseBuffers(const Core::Timing::CoreTiming& core_timing, const DeviceSession& session,
+                        bool force) {
         std::scoped_lock l{lock};
         bool buffer_released{false};
         while (registered_count > 0) {
@@ -103,7 +104,8 @@ public:
             }
 
             // Check with the backend if this buffer can be released yet.
-            if (!session.IsBufferConsumed(buffers[index])) {
+            // If we're shutting down, we don't care if it's been played or not.
+            if (!force && !session.IsBufferConsumed(buffers[index])) {
                 break;
             }
 

src/audio_core/device/device_session.cpp

@@ -73,6 +73,12 @@ void DeviceSession::Stop() {
     }
 }
 
+void DeviceSession::ClearBuffers() {
+    if (stream) {
+        stream->ClearQueue();
+    }
+}
+
 void DeviceSession::AppendBuffers(std::span<const AudioBuffer> buffers) const {
     for (const auto& buffer : buffers) {
         Sink::SinkBuffer new_buffer{

src/audio_core/device/device_session.h

@@ -90,6 +90,11 @@ public:
      */
     void Stop();
 
+    /**
+     * Clear out the underlying audio buffers in the backend stream.
+     */
+    void ClearBuffers();
+
     /**
      * Set this device session's volume.
      *

src/audio_core/in/audio_in_system.cpp

@@ -23,7 +23,6 @@ System::~System() {
 void System::Finalize() {
     Stop();
     session->Finalize();
-    buffer_event->Signal();
 }
 
 void System::StartSession() {
@@ -102,6 +101,10 @@ Result System::Stop() {
     if (state == State::Started) {
         session->Stop();
         session->SetVolume(0.0f);
+        session->ClearBuffers();
+        if (buffers.ReleaseBuffers(system.CoreTiming(), *session, true)) {
+            buffer_event->Signal();
+        }
         state = State::Stopped;
     }
 
@@ -138,7 +141,7 @@ void System::RegisterBuffers() {
 }
 
 void System::ReleaseBuffers() {
-    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session)};
+    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session, false)};
 
     if (signal) {
         // Signal if any buffer was released, or if none are registered, we need more.

src/audio_core/out/audio_out_system.cpp

@@ -24,7 +24,6 @@ System::~System() {
 void System::Finalize() {
     Stop();
     session->Finalize();
-    buffer_event->Signal();
 }
 
 std::string_view System::GetDefaultOutputDeviceName() const {
@@ -102,6 +101,10 @@ Result System::Stop() {
     if (state == State::Started) {
         session->Stop();
         session->SetVolume(0.0f);
+        session->ClearBuffers();
+        if (buffers.ReleaseBuffers(system.CoreTiming(), *session, true)) {
+            buffer_event->Signal();
+        }
         state = State::Stopped;
     }
 
@@ -138,7 +141,7 @@ void System::RegisterBuffers() {
 }
 
 void System::ReleaseBuffers() {
-    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session)};
+    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session, false)};
     if (signal) {
         // Signal if any buffer was released, or if none are registered, we need more.
         buffer_event->Signal();

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/assert.h

@@ -69,7 +69,7 @@ void assert_fail_impl();
 #define ASSERT_OR_EXECUTE(_a_, _b_)                                                                \
     do {                                                                                           \
         ASSERT(_a_);                                                                               \
-        if (!(_a_)) {                                                                              \
+        if (!(_a_)) [[unlikely]] {                                                                 \
             _b_                                                                                    \
         }                                                                                          \
     } while (0)
@@ -78,7 +78,7 @@ void assert_fail_impl();
 #define ASSERT_OR_EXECUTE_MSG(_a_, _b_, ...)                                                       \
     do {                                                                                           \
         ASSERT_MSG(_a_, __VA_ARGS__);                                                              \
-        if (!(_a_)) {                                                                              \
+        if (!(_a_)) [[unlikely]] {                                                                 \
             _b_                                                                                    \
         }                                                                                          \
     } while (0)

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.cpp

@@ -40,6 +40,7 @@ void LogSettings() {
     LOG_INFO(Config, "yuzu Configuration:");
     log_setting("Controls_UseDockedMode", values.use_docked_mode.GetValue());
     log_setting("System_RngSeed", values.rng_seed.GetValue().value_or(0));
+    log_setting("System_DeviceName", values.device_name.GetValue());
     log_setting("System_CurrentUser", values.current_user.GetValue());
     log_setting("System_LanguageIndex", values.language_index.GetValue());
     log_setting("System_RegionIndex", values.region_index.GetValue());

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 {
@@ -457,6 +458,7 @@ struct Values {
 
     // System
     SwitchableSetting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
+    Setting<std::string> device_name{"Yuzu", "device_name"};
     // Measured in seconds since epoch
     std::optional<s64> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`

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

@@ -201,6 +201,9 @@ add_library(core STATIC
     hle/kernel/k_event_info.h
     hle/kernel/k_handle_table.cpp
     hle/kernel/k_handle_table.h
+    hle/kernel/k_hardware_timer_base.h
+    hle/kernel/k_hardware_timer.cpp
+    hle/kernel/k_hardware_timer.h
     hle/kernel/k_interrupt_manager.cpp
     hle/kernel/k_interrupt_manager.h
     hle/kernel/k_light_condition_variable.cpp
@@ -268,6 +271,7 @@ add_library(core STATIC
     hle/kernel/k_thread_local_page.h
     hle/kernel/k_thread_queue.cpp
     hle/kernel/k_thread_queue.h
+    hle/kernel/k_timer_task.h
     hle/kernel/k_trace.h
     hle/kernel/k_transfer_memory.cpp
     hle/kernel/k_transfer_memory.h
@@ -290,8 +294,6 @@ add_library(core STATIC
     hle/kernel/svc_common.h
     hle/kernel/svc_types.h
     hle/kernel/svc_wrap.h
-    hle/kernel/time_manager.cpp
-    hle/kernel/time_manager.h
     hle/result.h
     hle/service/acc/acc.cpp
     hle/service/acc/acc.h

src/core/core.cpp

@@ -183,26 +183,20 @@ struct System::Impl {
         Initialize(system);
     }
 
-    SystemResultStatus Run() {
+    void Run() {
         std::unique_lock<std::mutex> lk(suspend_guard);
-        status = SystemResultStatus::Success;
 
         kernel.Suspend(false);
         core_timing.SyncPause(false);
         is_paused.store(false, std::memory_order_relaxed);
-
-        return status;
     }
 
-    SystemResultStatus Pause() {
+    void Pause() {
         std::unique_lock<std::mutex> lk(suspend_guard);
-        status = SystemResultStatus::Success;
 
         core_timing.SyncPause(true);
         kernel.Suspend(true);
         is_paused.store(true, std::memory_order_relaxed);
-
-        return status;
     }
 
     bool IsPaused() const {
@@ -389,7 +383,9 @@ struct System::Impl {
         kernel.ShutdownCores();
         cpu_manager.Shutdown();
         debugger.reset();
-        services->KillNVNFlinger();
+        if (services) {
+            services->KillNVNFlinger();
+        }
         kernel.CloseServices();
         services.reset();
         service_manager.reset();
@@ -551,12 +547,12 @@ void System::Initialize() {
     impl->Initialize(*this);
 }
 
-SystemResultStatus System::Run() {
-    return impl->Run();
+void System::Run() {
+    impl->Run();
 }
 
-SystemResultStatus System::Pause() {
-    return impl->Pause();
+void System::Pause() {
+    impl->Pause();
 }
 
 bool System::IsPaused() const {

src/core/core.h

@@ -152,13 +152,13 @@ public:
      * Run the OS and Application
      * This function will start emulation and run the relevant devices
      */
-    [[nodiscard]] SystemResultStatus Run();
+    void Run();
 
     /**
      * Pause the OS and Application
      * This function will pause emulation and stop the relevant devices
      */
-    [[nodiscard]] SystemResultStatus Pause();
+    void Pause();
 
     /// Check if the core is currently paused.
     [[nodiscard]] bool IsPaused() const;

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/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_controller.cpp

@@ -145,6 +145,7 @@ void EmulatedController::LoadDevices() {
     output_params[3].Set("output", true);
 
     LoadTASParams();
+    LoadVirtualGamepadParams();
 
     std::ranges::transform(button_params, button_devices.begin(), Common::Input::CreateInputDevice);
     std::ranges::transform(stick_params, stick_devices.begin(), Common::Input::CreateInputDevice);
@@ -163,6 +164,12 @@ void EmulatedController::LoadDevices() {
                            Common::Input::CreateInputDevice);
     std::ranges::transform(tas_stick_params, tas_stick_devices.begin(),
                            Common::Input::CreateInputDevice);
+
+    // Initialize virtual gamepad devices
+    std::ranges::transform(virtual_button_params, virtual_button_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(virtual_stick_params, virtual_stick_devices.begin(),
+                           Common::Input::CreateInputDevice);
 }
 
 void EmulatedController::LoadTASParams() {
@@ -205,6 +212,46 @@ void EmulatedController::LoadTASParams() {
     tas_stick_params[Settings::NativeAnalog::RStick].Set("axis_y", 3);
 }
 
+void EmulatedController::LoadVirtualGamepadParams() {
+    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    Common::ParamPackage common_params{};
+    common_params.Set("engine", "virtual_gamepad");
+    common_params.Set("port", static_cast<int>(player_index));
+    for (auto& param : virtual_button_params) {
+        param = common_params;
+    }
+    for (auto& param : virtual_stick_params) {
+        param = common_params;
+    }
+
+    // TODO(german77): Replace this with an input profile or something better
+    virtual_button_params[Settings::NativeButton::A].Set("button", 0);
+    virtual_button_params[Settings::NativeButton::B].Set("button", 1);
+    virtual_button_params[Settings::NativeButton::X].Set("button", 2);
+    virtual_button_params[Settings::NativeButton::Y].Set("button", 3);
+    virtual_button_params[Settings::NativeButton::LStick].Set("button", 4);
+    virtual_button_params[Settings::NativeButton::RStick].Set("button", 5);
+    virtual_button_params[Settings::NativeButton::L].Set("button", 6);
+    virtual_button_params[Settings::NativeButton::R].Set("button", 7);
+    virtual_button_params[Settings::NativeButton::ZL].Set("button", 8);
+    virtual_button_params[Settings::NativeButton::ZR].Set("button", 9);
+    virtual_button_params[Settings::NativeButton::Plus].Set("button", 10);
+    virtual_button_params[Settings::NativeButton::Minus].Set("button", 11);
+    virtual_button_params[Settings::NativeButton::DLeft].Set("button", 12);
+    virtual_button_params[Settings::NativeButton::DUp].Set("button", 13);
+    virtual_button_params[Settings::NativeButton::DRight].Set("button", 14);
+    virtual_button_params[Settings::NativeButton::DDown].Set("button", 15);
+    virtual_button_params[Settings::NativeButton::SL].Set("button", 16);
+    virtual_button_params[Settings::NativeButton::SR].Set("button", 17);
+    virtual_button_params[Settings::NativeButton::Home].Set("button", 18);
+    virtual_button_params[Settings::NativeButton::Screenshot].Set("button", 19);
+
+    virtual_stick_params[Settings::NativeAnalog::LStick].Set("axis_x", 0);
+    virtual_stick_params[Settings::NativeAnalog::LStick].Set("axis_y", 1);
+    virtual_stick_params[Settings::NativeAnalog::RStick].Set("axis_x", 2);
+    virtual_stick_params[Settings::NativeAnalog::RStick].Set("axis_y", 3);
+}
+
 void EmulatedController::ReloadInput() {
     // If you load any device here add the equivalent to the UnloadInput() function
     LoadDevices();
@@ -322,6 +369,35 @@ void EmulatedController::ReloadInput() {
                 },
         });
     }
+
+    // Use a common UUID for Virtual Gamepad
+    static constexpr Common::UUID VIRTUAL_UUID = Common::UUID{
+        {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
+
+    // Register virtual devices. No need to force update
+    for (std::size_t index = 0; index < virtual_button_devices.size(); ++index) {
+        if (!virtual_button_devices[index]) {
+            continue;
+        }
+        virtual_button_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetButton(callback, index, VIRTUAL_UUID);
+                },
+        });
+    }
+
+    for (std::size_t index = 0; index < virtual_stick_devices.size(); ++index) {
+        if (!virtual_stick_devices[index]) {
+            continue;
+        }
+        virtual_stick_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetStick(callback, index, VIRTUAL_UUID);
+                },
+        });
+    }
 }
 
 void EmulatedController::UnloadInput() {
@@ -349,6 +425,12 @@ void EmulatedController::UnloadInput() {
     for (auto& stick : tas_stick_devices) {
         stick.reset();
     }
+    for (auto& button : virtual_button_devices) {
+        button.reset();
+    }
+    for (auto& stick : virtual_stick_devices) {
+        stick.reset();
+    }
     camera_devices.reset();
     nfc_devices.reset();
 }

src/core/hid/emulated_controller.h

@@ -385,6 +385,9 @@ private:
     /// Set the params for TAS devices
     void LoadTASParams();
 
+    /// Set the params for virtual pad devices
+    void LoadVirtualGamepadParams();
+
     /**
      * @param use_temporary_value If true tmp_npad_type will be used
      * @return true if the controller style is fullkey
@@ -500,6 +503,12 @@ private:
     ButtonDevices tas_button_devices;
     StickDevices tas_stick_devices;
 
+    // Virtual gamepad related variables
+    ButtonParams virtual_button_params;
+    StickParams virtual_stick_params;
+    ButtonDevices virtual_button_devices;
+    StickDevices virtual_stick_devices;
+
     mutable std::mutex mutex;
     mutable std::mutex callback_mutex;
     std::unordered_map<int, ControllerUpdateCallback> callback_list;

src/core/hle/kernel/hle_ipc.cpp

@@ -167,6 +167,9 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
         }
         if (incoming) {
             // Populate the object lists with the data in the IPC request.
+            incoming_copy_handles.reserve(handle_descriptor_header->num_handles_to_copy);
+            incoming_move_handles.reserve(handle_descriptor_header->num_handles_to_move);
+
             for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_copy; ++handle) {
                 incoming_copy_handles.push_back(rp.Pop<Handle>());
             }
@@ -181,6 +184,11 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
         }
     }
 
+    buffer_x_desciptors.reserve(command_header->num_buf_x_descriptors);
+    buffer_a_desciptors.reserve(command_header->num_buf_a_descriptors);
+    buffer_b_desciptors.reserve(command_header->num_buf_b_descriptors);
+    buffer_w_desciptors.reserve(command_header->num_buf_w_descriptors);
+
     for (u32 i = 0; i < command_header->num_buf_x_descriptors; ++i) {
         buffer_x_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorX>());
     }
@@ -318,25 +326,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_address_arbiter.cpp

@@ -10,7 +10,6 @@
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
-#include "core/hle/kernel/time_manager.h"
 #include "core/memory.h"
 
 namespace Kernel {

src/core/hle/kernel/k_hardware_timer.cpp

@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/k_hardware_timer.h"
+#include "core/hle/kernel/k_scheduler.h"
+
+namespace Kernel {
+
+void KHardwareTimer::Initialize() {
+    // Create the timing callback to register with CoreTiming.
+    m_event_type = Core::Timing::CreateEvent(
+        "KHardwareTimer::Callback", [](std::uintptr_t timer_handle, s64, std::chrono::nanoseconds) {
+            reinterpret_cast<KHardwareTimer*>(timer_handle)->DoTask();
+            return std::nullopt;
+        });
+}
+
+void KHardwareTimer::Finalize() {
+    this->DisableInterrupt();
+    m_event_type.reset();
+}
+
+void KHardwareTimer::DoTask() {
+    // Handle the interrupt.
+    {
+        KScopedSchedulerLock slk{m_kernel};
+        KScopedSpinLock lk(this->GetLock());
+
+        //! Ignore this event if needed.
+        if (!this->GetInterruptEnabled()) {
+            return;
+        }
+
+        // Disable the timer interrupt while we handle this.
+        this->DisableInterrupt();
+
+        if (const s64 next_time = this->DoInterruptTaskImpl(GetTick());
+            0 < next_time && next_time <= m_wakeup_time) {
+            // We have a next time, so we should set the time to interrupt and turn the interrupt
+            // on.
+            this->EnableInterrupt(next_time);
+        }
+    }
+
+    // Clear the timer interrupt.
+    // Kernel::GetInterruptManager().ClearInterrupt(KInterruptName_NonSecurePhysicalTimer,
+    //                                              GetCurrentCoreId());
+}
+
+void KHardwareTimer::EnableInterrupt(s64 wakeup_time) {
+    this->DisableInterrupt();
+
+    m_wakeup_time = wakeup_time;
+    m_kernel.System().CoreTiming().ScheduleEvent(std::chrono::nanoseconds{m_wakeup_time},
+                                                 m_event_type, reinterpret_cast<uintptr_t>(this),
+                                                 true);
+}
+
+void KHardwareTimer::DisableInterrupt() {
+    m_kernel.System().CoreTiming().UnscheduleEvent(m_event_type, reinterpret_cast<uintptr_t>(this));
+    m_wakeup_time = std::numeric_limits<s64>::max();
+}
+
+s64 KHardwareTimer::GetTick() const {
+    return m_kernel.System().CoreTiming().GetGlobalTimeNs().count();
+}
+
+bool KHardwareTimer::GetInterruptEnabled() {
+    return m_wakeup_time != std::numeric_limits<s64>::max();
+}
+
+} // namespace Kernel

src/core/hle/kernel/k_hardware_timer.h

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/kernel/k_hardware_timer_base.h"
+
+namespace Core::Timing {
+struct EventType;
+} // namespace Core::Timing
+
+namespace Kernel {
+
+class KHardwareTimer : /* public KInterruptTask, */ public KHardwareTimerBase {
+public:
+    explicit KHardwareTimer(KernelCore& kernel) : KHardwareTimerBase{kernel} {}
+
+    // Public API.
+    void Initialize();
+    void Finalize();
+
+    s64 GetCount() const {
+        return GetTick();
+    }
+
+    void RegisterTask(KTimerTask* task, s64 time_from_now) {
+        this->RegisterAbsoluteTask(task, GetTick() + time_from_now);
+    }
+
+    void RegisterAbsoluteTask(KTimerTask* task, s64 task_time) {
+        KScopedDisableDispatch dd{m_kernel};
+        KScopedSpinLock lk{this->GetLock()};
+
+        if (this->RegisterAbsoluteTaskImpl(task, task_time)) {
+            if (task_time <= m_wakeup_time) {
+                this->EnableInterrupt(task_time);
+            }
+        }
+    }
+
+private:
+    void EnableInterrupt(s64 wakeup_time);
+    void DisableInterrupt();
+    bool GetInterruptEnabled();
+    s64 GetTick() const;
+    void DoTask();
+
+private:
+    // Absolute time in nanoseconds
+    s64 m_wakeup_time{std::numeric_limits<s64>::max()};
+    std::shared_ptr<Core::Timing::EventType> m_event_type{};
+};
+
+} // namespace Kernel

src/core/hle/kernel/k_hardware_timer_base.h

@@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/kernel/k_spin_lock.h"
+#include "core/hle/kernel/k_thread.h"
+#include "core/hle/kernel/k_timer_task.h"
+
+namespace Kernel {
+
+class KHardwareTimerBase {
+public:
+    explicit KHardwareTimerBase(KernelCore& kernel) : m_kernel{kernel} {}
+
+    void CancelTask(KTimerTask* task) {
+        KScopedDisableDispatch dd{m_kernel};
+        KScopedSpinLock lk{m_lock};
+
+        if (const s64 task_time = task->GetTime(); task_time > 0) {
+            this->RemoveTaskFromTree(task);
+        }
+    }
+
+protected:
+    KSpinLock& GetLock() {
+        return m_lock;
+    }
+
+    s64 DoInterruptTaskImpl(s64 cur_time) {
+        // We want to handle all tasks, returning the next time that a task is scheduled.
+        while (true) {
+            // Get the next task. If there isn't one, return 0.
+            KTimerTask* task = m_next_task;
+            if (task == nullptr) {
+                return 0;
+            }
+
+            // If the task needs to be done in the future, do it in the future and not now.
+            if (const s64 task_time = task->GetTime(); task_time > cur_time) {
+                return task_time;
+            }
+
+            // Remove the task from the tree of tasks, and update our next task.
+            this->RemoveTaskFromTree(task);
+
+            // Handle the task.
+            task->OnTimer();
+        }
+    }
+
+    bool RegisterAbsoluteTaskImpl(KTimerTask* task, s64 task_time) {
+        ASSERT(task_time > 0);
+
+        // Set the task's time, and insert it into our tree.
+        task->SetTime(task_time);
+        m_task_tree.insert(*task);
+
+        // Update our next task if relevant.
+        if (m_next_task != nullptr && m_next_task->GetTime() <= task_time) {
+            return false;
+        }
+        m_next_task = task;
+        return true;
+    }
+
+private:
+    void RemoveTaskFromTree(KTimerTask* task) {
+        // Erase from the tree.
+        auto it = m_task_tree.erase(m_task_tree.iterator_to(*task));
+
+        // Clear the task's scheduled time.
+        task->SetTime(0);
+
+        // Update our next task if relevant.
+        if (m_next_task == task) {
+            m_next_task = (it != m_task_tree.end()) ? std::addressof(*it) : nullptr;
+        }
+    }
+
+protected:
+    KernelCore& m_kernel;
+
+private:
+    using TimerTaskTree = Common::IntrusiveRedBlackTreeBaseTraits<KTimerTask>::TreeType<KTimerTask>;
+
+    KSpinLock m_lock{};
+    TimerTaskTree m_task_tree{};
+    KTimerTask* m_next_task{};
+};
+
+} // namespace Kernel

src/core/hle/kernel/k_process.cpp

@@ -285,6 +285,17 @@ void KProcess::UnregisterThread(KThread* thread) {
     thread_list.remove(thread);
 }
 
+u64 KProcess::GetFreeThreadCount() const {
+    if (resource_limit != nullptr) {
+        const auto current_value =
+            resource_limit->GetCurrentValue(LimitableResource::ThreadCountMax);
+        const auto limit_value = resource_limit->GetLimitValue(LimitableResource::ThreadCountMax);
+        return limit_value - current_value;
+    } else {
+        return 0;
+    }
+}
+
 Result KProcess::Reset() {
     // Lock the process and the scheduler.
     KScopedLightLock lk(state_lock);

src/core/hle/kernel/k_process.h

@@ -304,6 +304,9 @@ public:
     /// from this process' thread list.
     void UnregisterThread(KThread* thread);
 
+    /// Retrieves the number of available threads for this process.
+    u64 GetFreeThreadCount() const;
+
     /// Clears the signaled state of the process if and only if it's signaled.
     ///
     /// @pre The process must not be already terminated. If this is called on a

src/core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h

@@ -5,9 +5,9 @@
 
 #include "common/common_types.h"
 #include "core/hle/kernel/global_scheduler_context.h"
+#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/time_manager.h"
 
 namespace Kernel {
 
@@ -22,7 +22,7 @@ public:
     ~KScopedSchedulerLockAndSleep() {
         // Register the sleep.
         if (timeout_tick > 0) {
-            kernel.TimeManager().ScheduleTimeEvent(thread, timeout_tick);
+            kernel.HardwareTimer().RegisterTask(thread, timeout_tick);
         }
 
         // Unlock the scheduler.

src/core/hle/kernel/k_thread.h

@@ -22,6 +22,7 @@
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/k_spin_lock.h"
 #include "core/hle/kernel/k_synchronization_object.h"
+#include "core/hle/kernel/k_timer_task.h"
 #include "core/hle/kernel/k_worker_task.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/kernel/svc_common.h"
@@ -112,7 +113,8 @@ void SetCurrentThread(KernelCore& kernel, KThread* thread);
 [[nodiscard]] s32 GetCurrentCoreId(KernelCore& kernel);
 
 class KThread final : public KAutoObjectWithSlabHeapAndContainer<KThread, KWorkerTask>,
-                      public boost::intrusive::list_base_hook<> {
+                      public boost::intrusive::list_base_hook<>,
+                      public KTimerTask {
     KERNEL_AUTOOBJECT_TRAITS(KThread, KSynchronizationObject);
 
 private:
@@ -840,4 +842,8 @@ private:
     KernelCore& kernel;
 };
 
+inline void KTimerTask::OnTimer() {
+    static_cast<KThread*>(this)->OnTimer();
+}
+
 } // namespace Kernel

src/core/hle/kernel/k_thread_queue.cpp

@@ -1,9 +1,9 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/time_manager.h"
 
 namespace Kernel {
 
@@ -22,7 +22,7 @@ void KThreadQueue::EndWait(KThread* waiting_thread, Result wait_result) {
     waiting_thread->ClearWaitQueue();
 
     // Cancel the thread task.
-    kernel.TimeManager().UnscheduleTimeEvent(waiting_thread);
+    kernel.HardwareTimer().CancelTask(waiting_thread);
 }
 
 void KThreadQueue::CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) {
@@ -37,7 +37,7 @@ void KThreadQueue::CancelWait(KThread* waiting_thread, Result wait_result, bool
 
     // Cancel the thread task.
     if (cancel_timer_task) {
-        kernel.TimeManager().UnscheduleTimeEvent(waiting_thread);
+        kernel.HardwareTimer().CancelTask(waiting_thread);
     }
 }
 

src/core/hle/kernel/k_timer_task.h

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/intrusive_red_black_tree.h"
+
+namespace Kernel {
+
+class KTimerTask : public Common::IntrusiveRedBlackTreeBaseNode<KTimerTask> {
+public:
+    static constexpr int Compare(const KTimerTask& lhs, const KTimerTask& rhs) {
+        if (lhs.GetTime() < rhs.GetTime()) {
+            return -1;
+        } else {
+            return 1;
+        }
+    }
+
+    constexpr explicit KTimerTask() = default;
+
+    constexpr void SetTime(s64 t) {
+        m_time = t;
+    }
+
+    constexpr s64 GetTime() const {
+        return m_time;
+    }
+
+    // NOTE: This is virtual in Nintendo's kernel. Prior to 13.0.0, KWaitObject was also a
+    // TimerTask; this is no longer the case. Since this is now KThread exclusive, we have
+    // devirtualized (see inline declaration for this inside k_thread.h).
+    void OnTimer();
+
+private:
+    // Absolute time in nanoseconds
+    s64 m_time{};
+};
+
+} // namespace Kernel

src/core/hle/kernel/kernel.cpp

@@ -26,6 +26,7 @@
 #include "core/hle/kernel/k_client_port.h"
 #include "core/hle/kernel/k_dynamic_resource_manager.h"
 #include "core/hle/kernel/k_handle_table.h"
+#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_page_buffer.h"
@@ -39,7 +40,6 @@
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/service_thread.h"
-#include "core/hle/kernel/time_manager.h"
 #include "core/hle/result.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/memory.h"
@@ -55,7 +55,7 @@ struct KernelCore::Impl {
     static constexpr size_t ReservedDynamicPageCount = 64;
 
     explicit Impl(Core::System& system_, KernelCore& kernel_)
-        : time_manager{system_}, service_threads_manager{1, "ServiceThreadsManager"},
+        : service_threads_manager{1, "ServiceThreadsManager"},
           service_thread_barrier{2}, system{system_} {}
 
     void SetMulticore(bool is_multi) {
@@ -63,6 +63,9 @@ struct KernelCore::Impl {
     }
 
     void Initialize(KernelCore& kernel) {
+        hardware_timer = std::make_unique<Kernel::KHardwareTimer>(kernel);
+        hardware_timer->Initialize();
+
         global_object_list_container = std::make_unique<KAutoObjectWithListContainer>(kernel);
         global_scheduler_context = std::make_unique<Kernel::GlobalSchedulerContext>(kernel);
         global_handle_table = std::make_unique<Kernel::KHandleTable>(kernel);
@@ -104,12 +107,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() {
@@ -189,6 +196,9 @@ struct KernelCore::Impl {
         // Ensure that the object list container is finalized and properly shutdown.
         global_object_list_container->Finalize();
         global_object_list_container.reset();
+
+        hardware_timer->Finalize();
+        hardware_timer.reset();
     }
 
     void CloseServices() {
@@ -828,7 +838,7 @@ struct KernelCore::Impl {
     std::vector<KProcess*> process_list;
     std::atomic<KProcess*> current_process{};
     std::unique_ptr<Kernel::GlobalSchedulerContext> global_scheduler_context;
-    Kernel::TimeManager time_manager;
+    std::unique_ptr<Kernel::KHardwareTimer> hardware_timer;
 
     Init::KSlabResourceCounts slab_resource_counts{};
     KResourceLimit* system_resource_limit{};
@@ -1015,12 +1025,8 @@ Kernel::KScheduler* KernelCore::CurrentScheduler() {
     return impl->schedulers[core_id].get();
 }
 
-Kernel::TimeManager& KernelCore::TimeManager() {
-    return impl->time_manager;
-}
-
-const Kernel::TimeManager& KernelCore::TimeManager() const {
-    return impl->time_manager;
+Kernel::KHardwareTimer& KernelCore::HardwareTimer() {
+    return *impl->hardware_timer;
 }
 
 Core::ExclusiveMonitor& KernelCore::GetExclusiveMonitor() {

src/core/hle/kernel/kernel.h

@@ -39,6 +39,7 @@ class KDynamicPageManager;
 class KEvent;
 class KEventInfo;
 class KHandleTable;
+class KHardwareTimer;
 class KLinkedListNode;
 class KMemoryLayout;
 class KMemoryManager;
@@ -63,7 +64,6 @@ class KCodeMemory;
 class PhysicalCore;
 class ServiceThread;
 class Synchronization;
-class TimeManager;
 
 using ServiceInterfaceFactory =
     std::function<KClientPort&(Service::SM::ServiceManager&, Core::System&)>;
@@ -175,11 +175,8 @@ public:
     /// Gets the an instance of the current physical CPU core.
     const Kernel::PhysicalCore& CurrentPhysicalCore() const;
 
-    /// Gets the an instance of the TimeManager Interface.
-    Kernel::TimeManager& TimeManager();
-
-    /// Gets the an instance of the TimeManager Interface.
-    const Kernel::TimeManager& TimeManager() const;
+    /// Gets the an instance of the hardware timer.
+    Kernel::KHardwareTimer& HardwareTimer();
 
     /// Stops execution of 'id' core, in order to reschedule a new thread.
     void PrepareReschedule(std::size_t id);

src/core/hle/kernel/svc.cpp

@@ -784,63 +784,29 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
     LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
               info_sub_id, handle);
 
-    enum class GetInfoType : u64 {
-        // 1.0.0+
-        AllowedCPUCoreMask = 0,
-        AllowedThreadPriorityMask = 1,
-        MapRegionBaseAddr = 2,
-        MapRegionSize = 3,
-        HeapRegionBaseAddr = 4,
-        HeapRegionSize = 5,
-        TotalPhysicalMemoryAvailable = 6,
-        TotalPhysicalMemoryUsed = 7,
-        IsCurrentProcessBeingDebugged = 8,
-        RegisterResourceLimit = 9,
-        IdleTickCount = 10,
-        RandomEntropy = 11,
-        ThreadTickCount = 0xF0000002,
-        // 2.0.0+
-        ASLRRegionBaseAddr = 12,
-        ASLRRegionSize = 13,
-        StackRegionBaseAddr = 14,
-        StackRegionSize = 15,
-        // 3.0.0+
-        SystemResourceSize = 16,
-        SystemResourceUsage = 17,
-        TitleId = 18,
-        // 4.0.0+
-        PrivilegedProcessId = 19,
-        // 5.0.0+
-        UserExceptionContextAddr = 20,
-        // 6.0.0+
-        TotalPhysicalMemoryAvailableWithoutSystemResource = 21,
-        TotalPhysicalMemoryUsedWithoutSystemResource = 22,
-
-        // Homebrew only
-        MesosphereCurrentProcess = 65001,
-    };
-
-    const auto info_id_type = static_cast<GetInfoType>(info_id);
+    const auto info_id_type = static_cast<InfoType>(info_id);
 
     switch (info_id_type) {
-    case GetInfoType::AllowedCPUCoreMask:
-    case GetInfoType::AllowedThreadPriorityMask:
-    case GetInfoType::MapRegionBaseAddr:
-    case GetInfoType::MapRegionSize:
-    case GetInfoType::HeapRegionBaseAddr:
-    case GetInfoType::HeapRegionSize:
-    case GetInfoType::ASLRRegionBaseAddr:
-    case GetInfoType::ASLRRegionSize:
-    case GetInfoType::StackRegionBaseAddr:
-    case GetInfoType::StackRegionSize:
-    case GetInfoType::TotalPhysicalMemoryAvailable:
-    case GetInfoType::TotalPhysicalMemoryUsed:
-    case GetInfoType::SystemResourceSize:
-    case GetInfoType::SystemResourceUsage:
-    case GetInfoType::TitleId:
-    case GetInfoType::UserExceptionContextAddr:
-    case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
-    case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource: {
+    case InfoType::CoreMask:
+    case InfoType::PriorityMask:
+    case InfoType::AliasRegionAddress:
+    case InfoType::AliasRegionSize:
+    case InfoType::HeapRegionAddress:
+    case InfoType::HeapRegionSize:
+    case InfoType::AslrRegionAddress:
+    case InfoType::AslrRegionSize:
+    case InfoType::StackRegionAddress:
+    case InfoType::StackRegionSize:
+    case InfoType::TotalMemorySize:
+    case InfoType::UsedMemorySize:
+    case InfoType::SystemResourceSizeTotal:
+    case InfoType::SystemResourceSizeUsed:
+    case InfoType::ProgramId:
+    case InfoType::UserExceptionContextAddress:
+    case InfoType::TotalNonSystemMemorySize:
+    case InfoType::UsedNonSystemMemorySize:
+    case InfoType::IsApplication:
+    case InfoType::FreeThreadCount: {
         if (info_sub_id != 0) {
             LOG_ERROR(Kernel_SVC, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id,
                       info_sub_id);
@@ -856,79 +822,83 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
         }
 
         switch (info_id_type) {
-        case GetInfoType::AllowedCPUCoreMask:
+        case InfoType::CoreMask:
             *result = process->GetCoreMask();
             return ResultSuccess;
 
-        case GetInfoType::AllowedThreadPriorityMask:
+        case InfoType::PriorityMask:
             *result = process->GetPriorityMask();
             return ResultSuccess;
 
-        case GetInfoType::MapRegionBaseAddr:
+        case InfoType::AliasRegionAddress:
             *result = process->PageTable().GetAliasRegionStart();
             return ResultSuccess;
 
-        case GetInfoType::MapRegionSize:
+        case InfoType::AliasRegionSize:
             *result = process->PageTable().GetAliasRegionSize();
             return ResultSuccess;
 
-        case GetInfoType::HeapRegionBaseAddr:
+        case InfoType::HeapRegionAddress:
             *result = process->PageTable().GetHeapRegionStart();
             return ResultSuccess;
 
-        case GetInfoType::HeapRegionSize:
+        case InfoType::HeapRegionSize:
             *result = process->PageTable().GetHeapRegionSize();
             return ResultSuccess;
 
-        case GetInfoType::ASLRRegionBaseAddr:
+        case InfoType::AslrRegionAddress:
             *result = process->PageTable().GetAliasCodeRegionStart();
             return ResultSuccess;
 
-        case GetInfoType::ASLRRegionSize:
+        case InfoType::AslrRegionSize:
             *result = process->PageTable().GetAliasCodeRegionSize();
             return ResultSuccess;
 
-        case GetInfoType::StackRegionBaseAddr:
+        case InfoType::StackRegionAddress:
             *result = process->PageTable().GetStackRegionStart();
             return ResultSuccess;
 
-        case GetInfoType::StackRegionSize:
+        case InfoType::StackRegionSize:
             *result = process->PageTable().GetStackRegionSize();
             return ResultSuccess;
 
-        case GetInfoType::TotalPhysicalMemoryAvailable:
+        case InfoType::TotalMemorySize:
             *result = process->GetTotalPhysicalMemoryAvailable();
             return ResultSuccess;
 
-        case GetInfoType::TotalPhysicalMemoryUsed:
+        case InfoType::UsedMemorySize:
             *result = process->GetTotalPhysicalMemoryUsed();
             return ResultSuccess;
 
-        case GetInfoType::SystemResourceSize:
+        case InfoType::SystemResourceSizeTotal:
             *result = process->GetSystemResourceSize();
             return ResultSuccess;
 
-        case GetInfoType::SystemResourceUsage:
+        case InfoType::SystemResourceSizeUsed:
             LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query system resource usage");
             *result = process->GetSystemResourceUsage();
             return ResultSuccess;
 
-        case GetInfoType::TitleId:
+        case InfoType::ProgramId:
             *result = process->GetProgramID();
             return ResultSuccess;
 
-        case GetInfoType::UserExceptionContextAddr:
+        case InfoType::UserExceptionContextAddress:
             *result = process->GetProcessLocalRegionAddress();
             return ResultSuccess;
 
-        case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
+        case InfoType::TotalNonSystemMemorySize:
             *result = process->GetTotalPhysicalMemoryAvailableWithoutSystemResource();
             return ResultSuccess;
 
-        case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource:
+        case InfoType::UsedNonSystemMemorySize:
             *result = process->GetTotalPhysicalMemoryUsedWithoutSystemResource();
             return ResultSuccess;
 
+        case InfoType::FreeThreadCount:
+            *result = process->GetFreeThreadCount();
+            return ResultSuccess;
+
         default:
             break;
         }
@@ -937,11 +907,11 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
         return ResultInvalidEnumValue;
     }
 
-    case GetInfoType::IsCurrentProcessBeingDebugged:
+    case InfoType::DebuggerAttached:
         *result = 0;
         return ResultSuccess;
 
-    case GetInfoType::RegisterResourceLimit: {
+    case InfoType::ResourceLimit: {
         if (handle != 0) {
             LOG_ERROR(Kernel, "Handle is non zero! handle={:08X}", handle);
             return ResultInvalidHandle;
@@ -969,7 +939,7 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
         return ResultSuccess;
     }
 
-    case GetInfoType::RandomEntropy:
+    case InfoType::RandomEntropy:
         if (handle != 0) {
             LOG_ERROR(Kernel_SVC, "Process Handle is non zero, expected 0 result but got {:016X}",
                       handle);
@@ -985,13 +955,13 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
         *result = system.Kernel().CurrentProcess()->GetRandomEntropy(info_sub_id);
         return ResultSuccess;
 
-    case GetInfoType::PrivilegedProcessId:
+    case InfoType::InitialProcessIdRange:
         LOG_WARNING(Kernel_SVC,
                     "(STUBBED) Attempted to query privileged process id bounds, returned 0");
         *result = 0;
         return ResultSuccess;
 
-    case GetInfoType::ThreadTickCount: {
+    case InfoType::ThreadTickCount: {
         constexpr u64 num_cpus = 4;
         if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
             LOG_ERROR(Kernel_SVC, "Core count is out of range, expected {} but got {}", num_cpus,
@@ -1026,7 +996,7 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
         *result = out_ticks;
         return ResultSuccess;
     }
-    case GetInfoType::IdleTickCount: {
+    case InfoType::IdleTickCount: {
         // Verify the input handle is invalid.
         R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);
 
@@ -1040,7 +1010,7 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
         *result = system.Kernel().CurrentScheduler()->GetIdleThread()->GetCpuTime();
         return ResultSuccess;
     }
-    case GetInfoType::MesosphereCurrentProcess: {
+    case InfoType::MesosphereCurrentProcess: {
         // Verify the input handle is invalid.
         R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);
 

src/core/hle/kernel/time_manager.cpp

@@ -1,44 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/assert.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hle/kernel/k_scheduler.h"
-#include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/time_manager.h"
-
-namespace Kernel {
-
-TimeManager::TimeManager(Core::System& system_) : system{system_} {
-    time_manager_event_type = Core::Timing::CreateEvent(
-        "Kernel::TimeManagerCallback",
-        [this](std::uintptr_t thread_handle, s64 time,
-               std::chrono::nanoseconds) -> std::optional<std::chrono::nanoseconds> {
-            KThread* thread = reinterpret_cast<KThread*>(thread_handle);
-            {
-                KScopedSchedulerLock sl(system.Kernel());
-                thread->OnTimer();
-            }
-            return std::nullopt;
-        });
-}
-
-void TimeManager::ScheduleTimeEvent(KThread* thread, s64 nanoseconds) {
-    std::scoped_lock lock{mutex};
-    if (nanoseconds > 0) {
-        ASSERT(thread);
-        ASSERT(thread->GetState() != ThreadState::Runnable);
-        system.CoreTiming().ScheduleEvent(std::chrono::nanoseconds{nanoseconds},
-                                          time_manager_event_type,
-                                          reinterpret_cast<uintptr_t>(thread));
-    }
-}
-
-void TimeManager::UnscheduleTimeEvent(KThread* thread) {
-    std::scoped_lock lock{mutex};
-    system.CoreTiming().UnscheduleEvent(time_manager_event_type,
-                                        reinterpret_cast<uintptr_t>(thread));
-}
-
-} // namespace Kernel

src/core/hle/kernel/time_manager.h

@@ -1,41 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <memory>
-#include <mutex>
-
-namespace Core {
-class System;
-} // namespace Core
-
-namespace Core::Timing {
-struct EventType;
-} // namespace Core::Timing
-
-namespace Kernel {
-
-class KThread;
-
-/**
- * The `TimeManager` takes care of scheduling time events on threads and executes their TimeUp
- * method when the event is triggered.
- */
-class TimeManager {
-public:
-    explicit TimeManager(Core::System& system);
-
-    /// Schedule a time event on `timetask` thread that will expire in 'nanoseconds'
-    void ScheduleTimeEvent(KThread* time_task, s64 nanoseconds);
-
-    /// Unschedule an existing time event
-    void UnscheduleTimeEvent(KThread* thread);
-
-private:
-    Core::System& system;
-    std::shared_ptr<Core::Timing::EventType> time_manager_event_type;
-    std::mutex mutex;
-};
-
-} // namespace Kernel

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/nfc_user.cpp

@@ -97,7 +97,7 @@ void IUser::IsNfcEnabled(Kernel::HLERequestContext& ctx) {
 }
 
 void IUser::ListDevices(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_NFC, "called");
+    LOG_DEBUG(Service_NFC, "called");
 
     if (state == State::NonInitialized) {
         IPC::ResponseBuilder rb{ctx, 2};

src/core/hle/service/nfp/nfp_user.cpp

@@ -83,7 +83,7 @@ void IUser::Finalize(Kernel::HLERequestContext& ctx) {
 }
 
 void IUser::ListDevices(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_NFP, "called");
+    LOG_DEBUG(Service_NFP, "called");
 
     if (state == State::NonInitialized) {
         IPC::ResponseBuilder rb{ctx, 2};

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

@@ -191,6 +191,13 @@ void SET::GetKeyCodeMap2(Kernel::HLERequestContext& ctx) {
     GetKeyCodeMapImpl(ctx);
 }
 
+void SET::GetDeviceNickName(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+    ctx.WriteBuffer(Settings::values.device_name.GetValue());
+}
+
 SET::SET(Core::System& system_) : ServiceFramework{system_, "set"} {
     // clang-format off
     static const FunctionInfo functions[] = {
@@ -205,7 +212,7 @@ SET::SET(Core::System& system_) : ServiceFramework{system_, "set"} {
         {8, &SET::GetQuestFlag, "GetQuestFlag"},
         {9, &SET::GetKeyCodeMap2, "GetKeyCodeMap2"},
         {10, nullptr, "GetFirmwareVersionForDebug"},
-        {11, nullptr, "GetDeviceNickName"},
+        {11, &SET::GetDeviceNickName, "GetDeviceNickName"},
     };
     // clang-format on
 

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

@@ -50,6 +50,7 @@ private:
     void GetRegionCode(Kernel::HLERequestContext& ctx);
     void GetKeyCodeMap(Kernel::HLERequestContext& ctx);
     void GetKeyCodeMap2(Kernel::HLERequestContext& ctx);
+    void GetDeviceNickName(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Set

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

@@ -3,6 +3,7 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "common/settings.h"
 #include "core/file_sys/errors.h"
 #include "core/file_sys/system_archive/system_version.h"
 #include "core/hle/ipc_helpers.h"
@@ -176,6 +177,13 @@ void SET_SYS::GetSettingsItemValue(Kernel::HLERequestContext& ctx) {
     rb.Push(response);
 }
 
+void SET_SYS::GetDeviceNickName(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+    ctx.WriteBuffer(::Settings::values.device_name.GetValue());
+}
+
 SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
     // clang-format off
     static const FunctionInfo functions[] = {
@@ -253,7 +261,7 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {74, nullptr, "SetWirelessLanEnableFlag"},
         {75, nullptr, "GetInitialLaunchSettings"},
         {76, nullptr, "SetInitialLaunchSettings"},
-        {77, nullptr, "GetDeviceNickName"},
+        {77, &SET_SYS::GetDeviceNickName, "GetDeviceNickName"},
         {78, nullptr, "SetDeviceNickName"},
         {79, nullptr, "GetProductModel"},
         {80, nullptr, "GetLdnChannel"},

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

@@ -29,6 +29,7 @@ private:
     void GetFirmwareVersion2(Kernel::HLERequestContext& ctx);
     void GetColorSetId(Kernel::HLERequestContext& ctx);
     void SetColorSetId(Kernel::HLERequestContext& ctx);
+    void GetDeviceNickName(Kernel::HLERequestContext& ctx);
 
     ColorSet color_set = ColorSet::BasicWhite;
 };

src/core/hle/service/time/clock_types.h

@@ -49,6 +49,7 @@ struct SteadyClockContext {
 static_assert(sizeof(SteadyClockContext) == 0x18, "SteadyClockContext is incorrect size");
 static_assert(std::is_trivially_copyable_v<SteadyClockContext>,
               "SteadyClockContext must be trivially copyable");
+using StandardSteadyClockTimePointType = SteadyClockContext;
 
 struct SystemClockContext {
     s64 offset;

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

@@ -26,23 +26,24 @@ void SharedMemory::SetupStandardSteadyClock(const Common::UUID& clock_source_id,
     const Clock::SteadyClockContext context{
         static_cast<u64>(current_time_point.nanoseconds - ticks_time_span.nanoseconds),
         clock_source_id};
-    shared_memory_format.standard_steady_clock_timepoint.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), context);
+    StoreToLockFreeAtomicType(&GetFormat()->standard_steady_clock_timepoint, context);
 }
 
 void SharedMemory::UpdateLocalSystemClockContext(const Clock::SystemClockContext& context) {
-    shared_memory_format.standard_local_system_clock_context.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), context);
+    StoreToLockFreeAtomicType(&GetFormat()->standard_local_system_clock_context, context);
 }
 
 void SharedMemory::UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context) {
-    shared_memory_format.standard_network_system_clock_context.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), context);
+    StoreToLockFreeAtomicType(&GetFormat()->standard_network_system_clock_context, context);
 }
 
 void SharedMemory::SetAutomaticCorrectionEnabled(bool is_enabled) {
-    shared_memory_format.standard_user_system_clock_automatic_correction.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), is_enabled);
+    StoreToLockFreeAtomicType(
+        &GetFormat()->is_standard_user_system_clock_automatic_correction_enabled, is_enabled);
+}
+
+SharedMemory::Format* SharedMemory::GetFormat() {
+    return reinterpret_cast<SharedMemory::Format*>(system.Kernel().GetTimeSharedMem().GetPointer());
 }
 
 } // namespace Service::Time

src/core/hle/service/time/time_sharedmemory.h

@@ -10,45 +10,68 @@
 
 namespace Service::Time {
 
+// Note: this type is not safe for concurrent writes.
+template <typename T>
+struct LockFreeAtomicType {
+    u32 counter_;
+    std::array<T, 2> value_;
+};
+
+template <typename T>
+static inline void StoreToLockFreeAtomicType(LockFreeAtomicType<T>* p, const T& value) {
+    // Get the current counter.
+    auto counter = p->counter_;
+
+    // Increment the counter.
+    ++counter;
+
+    // Store the updated value.
+    p->value_[counter % 2] = value;
+
+    // Fence memory.
+    std::atomic_thread_fence(std::memory_order_release);
+
+    // Set the updated counter.
+    p->counter_ = counter;
+}
+
+template <typename T>
+static inline T LoadFromLockFreeAtomicType(const LockFreeAtomicType<T>* p) {
+    while (true) {
+        // Get the counter.
+        auto counter = p->counter_;
+
+        // Get the value.
+        auto value = p->value_[counter % 2];
+
+        // Fence memory.
+        std::atomic_thread_fence(std::memory_order_acquire);
+
+        // Check that the counter matches.
+        if (counter == p->counter_) {
+            return value;
+        }
+    }
+}
+
 class SharedMemory final {
 public:
     explicit SharedMemory(Core::System& system_);
     ~SharedMemory();
 
-    // TODO(ogniK): We have to properly simulate memory barriers, how are we going to do this?
-    template <typename T, std::size_t Offset>
-    struct MemoryBarrier {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
-        u32_le read_attempt{};
-        std::array<T, 2> data{};
-
-        // These are not actually memory barriers at the moment as we don't have multicore and all
-        // HLE is mutexed. This will need to properly be implemented when we start updating the time
-        // points on threads. As of right now, we'll be updated both values synchronously and just
-        // incrementing the read_attempt to indicate that we waited.
-        void StoreData(u8* shared_memory, T data_to_store) {
-            std::memcpy(this, shared_memory + Offset, sizeof(*this));
-            read_attempt++;
-            data[read_attempt & 1] = data_to_store;
-            std::memcpy(shared_memory + Offset, this, sizeof(*this));
-        }
-
-        // For reading we're just going to read the last stored value. If there was no value stored
-        // it will just end up reading an empty value as intended.
-        T ReadData(u8* shared_memory) {
-            std::memcpy(this, shared_memory + Offset, sizeof(*this));
-            return data[(read_attempt - 1) & 1];
-        }
-    };
-
     // Shared memory format
     struct Format {
-        MemoryBarrier<Clock::SteadyClockContext, 0x0> standard_steady_clock_timepoint;
-        MemoryBarrier<Clock::SystemClockContext, 0x38> standard_local_system_clock_context;
-        MemoryBarrier<Clock::SystemClockContext, 0x80> standard_network_system_clock_context;
-        MemoryBarrier<bool, 0xc8> standard_user_system_clock_automatic_correction;
-        u32_le format_version;
+        LockFreeAtomicType<Clock::StandardSteadyClockTimePointType> standard_steady_clock_timepoint;
+        LockFreeAtomicType<Clock::SystemClockContext> standard_local_system_clock_context;
+        LockFreeAtomicType<Clock::SystemClockContext> standard_network_system_clock_context;
+        LockFreeAtomicType<bool> is_standard_user_system_clock_automatic_correction_enabled;
+        u32 format_version;
     };
+    static_assert(offsetof(Format, standard_steady_clock_timepoint) == 0x0);
+    static_assert(offsetof(Format, standard_local_system_clock_context) == 0x38);
+    static_assert(offsetof(Format, standard_network_system_clock_context) == 0x80);
+    static_assert(offsetof(Format, is_standard_user_system_clock_automatic_correction_enabled) ==
+                  0xc8);
     static_assert(sizeof(Format) == 0xd8, "Format is an invalid size");
 
     void SetupStandardSteadyClock(const Common::UUID& clock_source_id,
@@ -56,10 +79,10 @@ public:
     void UpdateLocalSystemClockContext(const Clock::SystemClockContext& context);
     void UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context);
     void SetAutomaticCorrectionEnabled(bool is_enabled);
+    Format* GetFormat();
 
 private:
     Core::System& system;
-    Format shared_memory_format{};
 };
 
 } // namespace Service::Time

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"
@@ -340,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&) {
@@ -354,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/input_common/CMakeLists.txt

@@ -20,6 +20,8 @@ add_library(input_common STATIC
     drivers/udp_client.h
     drivers/virtual_amiibo.cpp
     drivers/virtual_amiibo.h
+    drivers/virtual_gamepad.cpp
+    drivers/virtual_gamepad.h
     helpers/stick_from_buttons.cpp
     helpers/stick_from_buttons.h
     helpers/touch_from_buttons.cpp

src/input_common/drivers/camera.cpp

@@ -17,7 +17,7 @@ Camera::Camera(std::string input_engine_) : InputEngine(std::move(input_engine_)
     PreSetController(identifier);
 }
 
-void Camera::SetCameraData(std::size_t width, std::size_t height, std::vector<u32> data) {
+void Camera::SetCameraData(std::size_t width, std::size_t height, std::span<const u32> data) {
     const std::size_t desired_width = getImageWidth();
     const std::size_t desired_height = getImageHeight();
     status.data.resize(desired_width * desired_height);

src/input_common/drivers/camera.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <span>
+
 #include "input_common/input_engine.h"
 
 namespace InputCommon {
@@ -15,7 +17,7 @@ class Camera final : public InputEngine {
 public:
     explicit Camera(std::string input_engine_);
 
-    void SetCameraData(std::size_t width, std::size_t height, std::vector<u32> data);
+    void SetCameraData(std::size_t width, std::size_t height, std::span<const u32> data);
 
     std::size_t getImageWidth() const;
     std::size_t getImageHeight() const;
@@ -23,6 +25,7 @@ public:
     Common::Input::CameraError SetCameraFormat(const PadIdentifier& identifier_,
                                                Common::Input::CameraFormat camera_format) override;
 
+private:
     Common::Input::CameraStatus status{};
 };
 

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_gamepad.cpp

@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "input_common/drivers/virtual_gamepad.h"
+
+namespace InputCommon {
+constexpr std::size_t PlayerIndexCount = 10;
+
+VirtualGamepad::VirtualGamepad(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+    for (std::size_t i = 0; i < PlayerIndexCount; i++) {
+        PreSetController(GetIdentifier(i));
+    }
+}
+
+void VirtualGamepad::SetButtonState(std::size_t player_index, int button_id, bool value) {
+    if (player_index > PlayerIndexCount) {
+        return;
+    }
+    const auto identifier = GetIdentifier(player_index);
+    SetButton(identifier, button_id, value);
+}
+
+void VirtualGamepad::SetButtonState(std::size_t player_index, VirtualButton button_id, bool value) {
+    SetButtonState(player_index, static_cast<int>(button_id), value);
+}
+
+void VirtualGamepad::SetStickPosition(std::size_t player_index, int axis_id, float x_value,
+                                      float y_value) {
+    if (player_index > PlayerIndexCount) {
+        return;
+    }
+    const auto identifier = GetIdentifier(player_index);
+    SetAxis(identifier, axis_id * 2, x_value);
+    SetAxis(identifier, (axis_id * 2) + 1, y_value);
+}
+
+void VirtualGamepad::SetStickPosition(std::size_t player_index, VirtualStick axis_id, float x_value,
+                                      float y_value) {
+    SetStickPosition(player_index, static_cast<int>(axis_id), x_value, y_value);
+}
+
+void VirtualGamepad::ResetControllers() {
+    for (std::size_t i = 0; i < PlayerIndexCount; i++) {
+        SetStickPosition(i, VirtualStick::Left, 0.0f, 0.0f);
+        SetStickPosition(i, VirtualStick::Right, 0.0f, 0.0f);
+
+        SetButtonState(i, VirtualButton::ButtonA, false);
+        SetButtonState(i, VirtualButton::ButtonB, false);
+        SetButtonState(i, VirtualButton::ButtonX, false);
+        SetButtonState(i, VirtualButton::ButtonY, false);
+        SetButtonState(i, VirtualButton::StickL, false);
+        SetButtonState(i, VirtualButton::StickR, false);
+        SetButtonState(i, VirtualButton::TriggerL, false);
+        SetButtonState(i, VirtualButton::TriggerR, false);
+        SetButtonState(i, VirtualButton::TriggerZL, false);
+        SetButtonState(i, VirtualButton::TriggerZR, false);
+        SetButtonState(i, VirtualButton::ButtonPlus, false);
+        SetButtonState(i, VirtualButton::ButtonMinus, false);
+        SetButtonState(i, VirtualButton::ButtonLeft, false);
+        SetButtonState(i, VirtualButton::ButtonUp, false);
+        SetButtonState(i, VirtualButton::ButtonRight, false);
+        SetButtonState(i, VirtualButton::ButtonDown, false);
+        SetButtonState(i, VirtualButton::ButtonSL, false);
+        SetButtonState(i, VirtualButton::ButtonSR, false);
+        SetButtonState(i, VirtualButton::ButtonHome, false);
+        SetButtonState(i, VirtualButton::ButtonCapture, false);
+    }
+}
+
+PadIdentifier VirtualGamepad::GetIdentifier(std::size_t player_index) const {
+    return {
+        .guid = Common::UUID{},
+        .port = player_index,
+        .pad = 0,
+    };
+}
+
+} // namespace InputCommon

src/input_common/drivers/virtual_gamepad.h

@@ -0,0 +1,73 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "input_common/input_engine.h"
+
+namespace InputCommon {
+
+/**
+ * A virtual controller that is always assigned to the game input
+ */
+class VirtualGamepad final : public InputEngine {
+public:
+    enum class VirtualButton {
+        ButtonA,
+        ButtonB,
+        ButtonX,
+        ButtonY,
+        StickL,
+        StickR,
+        TriggerL,
+        TriggerR,
+        TriggerZL,
+        TriggerZR,
+        ButtonPlus,
+        ButtonMinus,
+        ButtonLeft,
+        ButtonUp,
+        ButtonRight,
+        ButtonDown,
+        ButtonSL,
+        ButtonSR,
+        ButtonHome,
+        ButtonCapture,
+    };
+
+    enum class VirtualStick {
+        Left = 0,
+        Right = 1,
+    };
+
+    explicit VirtualGamepad(std::string input_engine_);
+
+    /**
+     * Sets the status of all buttons bound with the key to pressed
+     * @param player_index the player number that will take this action
+     * @param button_id the id of the button
+     * @param value indicates if the button is pressed or not
+     */
+    void SetButtonState(std::size_t player_index, int button_id, bool value);
+    void SetButtonState(std::size_t player_index, VirtualButton button_id, bool value);
+
+    /**
+     * Sets the status of all buttons bound with the key to released
+     * @param player_index the player number that will take this action
+     * @param axis_id the id of the axis to move
+     * @param x_value the position of the stick in the x axis
+     * @param y_value the position of the stick in the y axis
+     */
+    void SetStickPosition(std::size_t player_index, int axis_id, float x_value, float y_value);
+    void SetStickPosition(std::size_t player_index, VirtualStick axis_id, float x_value,
+                          float y_value);
+
+    /// Restores all inputs into the neutral position
+    void ResetControllers();
+
+private:
+    /// Returns the correct identifier corresponding to the player index
+    PadIdentifier GetIdentifier(std::size_t player_index) const;
+};
+
+} // namespace InputCommon

src/input_common/input_mapping.cpp

@@ -200,12 +200,6 @@ bool MappingFactory::IsDriverValid(const MappingData& data) const {
         return false;
     }
     // The following drivers don't need to be mapped
-    if (data.engine == "tas") {
-        return false;
-    }
-    if (data.engine == "touch") {
-        return false;
-    }
     if (data.engine == "touch_from_button") {
         return false;
     }

src/input_common/main.cpp

@@ -12,6 +12,7 @@
 #include "input_common/drivers/touch_screen.h"
 #include "input_common/drivers/udp_client.h"
 #include "input_common/drivers/virtual_amiibo.h"
+#include "input_common/drivers/virtual_gamepad.h"
 #include "input_common/helpers/stick_from_buttons.h"
 #include "input_common/helpers/touch_from_buttons.h"
 #include "input_common/input_engine.h"
@@ -25,73 +26,33 @@
 namespace InputCommon {
 
 struct InputSubsystem::Impl {
-    void Initialize() {
-        mapping_factory = std::make_shared<MappingFactory>();
+    template <typename Engine>
+    void RegisterEngine(std::string name, std::shared_ptr<Engine>& engine) {
         MappingCallback mapping_callback{[this](const MappingData& data) { RegisterInput(data); }};
 
-        keyboard = std::make_shared<Keyboard>("keyboard");
-        keyboard->SetMappingCallback(mapping_callback);
-        keyboard_factory = std::make_shared<InputFactory>(keyboard);
-        keyboard_output_factory = std::make_shared<OutputFactory>(keyboard);
-        Common::Input::RegisterInputFactory(keyboard->GetEngineName(), keyboard_factory);
-        Common::Input::RegisterOutputFactory(keyboard->GetEngineName(), keyboard_output_factory);
+        engine = std::make_shared<Engine>(name);
+        engine->SetMappingCallback(mapping_callback);
 
-        mouse = std::make_shared<Mouse>("mouse");
-        mouse->SetMappingCallback(mapping_callback);
-        mouse_factory = std::make_shared<InputFactory>(mouse);
-        mouse_output_factory = std::make_shared<OutputFactory>(mouse);
-        Common::Input::RegisterInputFactory(mouse->GetEngineName(), mouse_factory);
-        Common::Input::RegisterOutputFactory(mouse->GetEngineName(), mouse_output_factory);
+        std::shared_ptr<InputFactory> input_factory = std::make_shared<InputFactory>(engine);
+        std::shared_ptr<OutputFactory> output_factory = std::make_shared<OutputFactory>(engine);
+        Common::Input::RegisterInputFactory(engine->GetEngineName(), std::move(input_factory));
+        Common::Input::RegisterOutputFactory(engine->GetEngineName(), std::move(output_factory));
+    }
 
-        touch_screen = std::make_shared<TouchScreen>("touch");
-        touch_screen_factory = std::make_shared<InputFactory>(touch_screen);
-        Common::Input::RegisterInputFactory(touch_screen->GetEngineName(), touch_screen_factory);
-
-        gcadapter = std::make_shared<GCAdapter>("gcpad");
-        gcadapter->SetMappingCallback(mapping_callback);
-        gcadapter_input_factory = std::make_shared<InputFactory>(gcadapter);
-        gcadapter_output_factory = std::make_shared<OutputFactory>(gcadapter);
-        Common::Input::RegisterInputFactory(gcadapter->GetEngineName(), gcadapter_input_factory);
-        Common::Input::RegisterOutputFactory(gcadapter->GetEngineName(), gcadapter_output_factory);
-
-        udp_client = std::make_shared<CemuhookUDP::UDPClient>("cemuhookudp");
-        udp_client->SetMappingCallback(mapping_callback);
-        udp_client_input_factory = std::make_shared<InputFactory>(udp_client);
-        udp_client_output_factory = std::make_shared<OutputFactory>(udp_client);
-        Common::Input::RegisterInputFactory(udp_client->GetEngineName(), udp_client_input_factory);
-        Common::Input::RegisterOutputFactory(udp_client->GetEngineName(),
-                                             udp_client_output_factory);
-
-        tas_input = std::make_shared<TasInput::Tas>("tas");
-        tas_input->SetMappingCallback(mapping_callback);
-        tas_input_factory = std::make_shared<InputFactory>(tas_input);
-        tas_output_factory = std::make_shared<OutputFactory>(tas_input);
-        Common::Input::RegisterInputFactory(tas_input->GetEngineName(), tas_input_factory);
-        Common::Input::RegisterOutputFactory(tas_input->GetEngineName(), tas_output_factory);
-
-        camera = std::make_shared<Camera>("camera");
-        camera->SetMappingCallback(mapping_callback);
-        camera_input_factory = std::make_shared<InputFactory>(camera);
-        camera_output_factory = std::make_shared<OutputFactory>(camera);
-        Common::Input::RegisterInputFactory(camera->GetEngineName(), camera_input_factory);
-        Common::Input::RegisterOutputFactory(camera->GetEngineName(), camera_output_factory);
-
-        virtual_amiibo = std::make_shared<VirtualAmiibo>("virtual_amiibo");
-        virtual_amiibo->SetMappingCallback(mapping_callback);
-        virtual_amiibo_input_factory = std::make_shared<InputFactory>(virtual_amiibo);
-        virtual_amiibo_output_factory = std::make_shared<OutputFactory>(virtual_amiibo);
-        Common::Input::RegisterInputFactory(virtual_amiibo->GetEngineName(),
-                                            virtual_amiibo_input_factory);
-        Common::Input::RegisterOutputFactory(virtual_amiibo->GetEngineName(),
-                                             virtual_amiibo_output_factory);
+    void Initialize() {
+        mapping_factory = std::make_shared<MappingFactory>();
 
+        RegisterEngine("keyboard", keyboard);
+        RegisterEngine("mouse", mouse);
+        RegisterEngine("touch", touch_screen);
+        RegisterEngine("gcpad", gcadapter);
+        RegisterEngine("cemuhookudp", udp_client);
+        RegisterEngine("tas", tas_input);
+        RegisterEngine("camera", camera);
+        RegisterEngine("virtual_amiibo", virtual_amiibo);
+        RegisterEngine("virtual_gamepad", virtual_gamepad);
 #ifdef HAVE_SDL2
-        sdl = std::make_shared<SDLDriver>("sdl");
-        sdl->SetMappingCallback(mapping_callback);
-        sdl_input_factory = std::make_shared<InputFactory>(sdl);
-        sdl_output_factory = std::make_shared<OutputFactory>(sdl);
-        Common::Input::RegisterInputFactory(sdl->GetEngineName(), sdl_input_factory);
-        Common::Input::RegisterOutputFactory(sdl->GetEngineName(), sdl_output_factory);
+        RegisterEngine("sdl", sdl);
 #endif
 
         Common::Input::RegisterInputFactory("touch_from_button",
@@ -100,42 +61,25 @@ struct InputSubsystem::Impl {
                                             std::make_shared<StickFromButton>());
     }
 
+    template <typename Engine>
+    void UnregisterEngine(std::shared_ptr<Engine>& engine) {
+        Common::Input::UnregisterInputFactory(engine->GetEngineName());
+        Common::Input::UnregisterOutputFactory(engine->GetEngineName());
+        engine.reset();
+    }
+
     void Shutdown() {
-        Common::Input::UnregisterInputFactory(keyboard->GetEngineName());
-        Common::Input::UnregisterOutputFactory(keyboard->GetEngineName());
-        keyboard.reset();
-
-        Common::Input::UnregisterInputFactory(mouse->GetEngineName());
-        Common::Input::UnregisterOutputFactory(mouse->GetEngineName());
-        mouse.reset();
-
-        Common::Input::UnregisterInputFactory(touch_screen->GetEngineName());
-        touch_screen.reset();
-
-        Common::Input::UnregisterInputFactory(gcadapter->GetEngineName());
-        Common::Input::UnregisterOutputFactory(gcadapter->GetEngineName());
-        gcadapter.reset();
-
-        Common::Input::UnregisterInputFactory(udp_client->GetEngineName());
-        Common::Input::UnregisterOutputFactory(udp_client->GetEngineName());
-        udp_client.reset();
-
-        Common::Input::UnregisterInputFactory(tas_input->GetEngineName());
-        Common::Input::UnregisterOutputFactory(tas_input->GetEngineName());
-        tas_input.reset();
-
-        Common::Input::UnregisterInputFactory(camera->GetEngineName());
-        Common::Input::UnregisterOutputFactory(camera->GetEngineName());
-        camera.reset();
-
-        Common::Input::UnregisterInputFactory(virtual_amiibo->GetEngineName());
-        Common::Input::UnregisterOutputFactory(virtual_amiibo->GetEngineName());
-        virtual_amiibo.reset();
-
+        UnregisterEngine(keyboard);
+        UnregisterEngine(mouse);
+        UnregisterEngine(touch_screen);
+        UnregisterEngine(gcadapter);
+        UnregisterEngine(udp_client);
+        UnregisterEngine(tas_input);
+        UnregisterEngine(camera);
+        UnregisterEngine(virtual_amiibo);
+        UnregisterEngine(virtual_gamepad);
 #ifdef HAVE_SDL2
-        Common::Input::UnregisterInputFactory(sdl->GetEngineName());
-        Common::Input::UnregisterOutputFactory(sdl->GetEngineName());
-        sdl.reset();
+        UnregisterEngine(sdl);
 #endif
 
         Common::Input::UnregisterInputFactory("touch_from_button");
@@ -163,117 +107,86 @@ struct InputSubsystem::Impl {
         return devices;
     }
 
-    [[nodiscard]] AnalogMapping GetAnalogMappingForDevice(
+    [[nodiscard]] std::shared_ptr<InputEngine> GetInputEngine(
         const Common::ParamPackage& params) const {
         if (!params.Has("engine") || params.Get("engine", "") == "any") {
-            return {};
+            return nullptr;
         }
         const std::string engine = params.Get("engine", "");
+        if (engine == keyboard->GetEngineName()) {
+            return keyboard;
+        }
         if (engine == mouse->GetEngineName()) {
-            return mouse->GetAnalogMappingForDevice(params);
+            return mouse;
         }
         if (engine == gcadapter->GetEngineName()) {
-            return gcadapter->GetAnalogMappingForDevice(params);
+            return gcadapter;
         }
         if (engine == udp_client->GetEngineName()) {
-            return udp_client->GetAnalogMappingForDevice(params);
-        }
-        if (engine == tas_input->GetEngineName()) {
-            return tas_input->GetAnalogMappingForDevice(params);
+            return udp_client;
         }
 #ifdef HAVE_SDL2
         if (engine == sdl->GetEngineName()) {
-            return sdl->GetAnalogMappingForDevice(params);
+            return sdl;
         }
 #endif
-        return {};
+        return nullptr;
+    }
+
+    [[nodiscard]] AnalogMapping GetAnalogMappingForDevice(
+        const Common::ParamPackage& params) const {
+        const auto input_engine = GetInputEngine(params);
+
+        if (input_engine == nullptr) {
+            return {};
+        }
+
+        return input_engine->GetAnalogMappingForDevice(params);
     }
 
     [[nodiscard]] ButtonMapping GetButtonMappingForDevice(
         const Common::ParamPackage& params) const {
-        if (!params.Has("engine") || params.Get("engine", "") == "any") {
+        const auto input_engine = GetInputEngine(params);
+
+        if (input_engine == nullptr) {
             return {};
         }
-        const std::string engine = params.Get("engine", "");
-        if (engine == gcadapter->GetEngineName()) {
-            return gcadapter->GetButtonMappingForDevice(params);
-        }
-        if (engine == udp_client->GetEngineName()) {
-            return udp_client->GetButtonMappingForDevice(params);
-        }
-        if (engine == tas_input->GetEngineName()) {
-            return tas_input->GetButtonMappingForDevice(params);
-        }
-#ifdef HAVE_SDL2
-        if (engine == sdl->GetEngineName()) {
-            return sdl->GetButtonMappingForDevice(params);
-        }
-#endif
-        return {};
+
+        return input_engine->GetButtonMappingForDevice(params);
     }
 
     [[nodiscard]] MotionMapping GetMotionMappingForDevice(
         const Common::ParamPackage& params) const {
-        if (!params.Has("engine") || params.Get("engine", "") == "any") {
+        const auto input_engine = GetInputEngine(params);
+
+        if (input_engine == nullptr) {
             return {};
         }
-        const std::string engine = params.Get("engine", "");
-        if (engine == udp_client->GetEngineName()) {
-            return udp_client->GetMotionMappingForDevice(params);
-        }
-#ifdef HAVE_SDL2
-        if (engine == sdl->GetEngineName()) {
-            return sdl->GetMotionMappingForDevice(params);
-        }
-#endif
-        return {};
+
+        return input_engine->GetMotionMappingForDevice(params);
     }
 
     Common::Input::ButtonNames GetButtonName(const Common::ParamPackage& params) const {
         if (!params.Has("engine") || params.Get("engine", "") == "any") {
             return Common::Input::ButtonNames::Undefined;
         }
-        const std::string engine = params.Get("engine", "");
-        if (engine == mouse->GetEngineName()) {
-            return mouse->GetUIName(params);
+        const auto input_engine = GetInputEngine(params);
+
+        if (input_engine == nullptr) {
+            return Common::Input::ButtonNames::Invalid;
         }
-        if (engine == gcadapter->GetEngineName()) {
-            return gcadapter->GetUIName(params);
-        }
-        if (engine == udp_client->GetEngineName()) {
-            return udp_client->GetUIName(params);
-        }
-        if (engine == tas_input->GetEngineName()) {
-            return tas_input->GetUIName(params);
-        }
-#ifdef HAVE_SDL2
-        if (engine == sdl->GetEngineName()) {
-            return sdl->GetUIName(params);
-        }
-#endif
-        return Common::Input::ButtonNames::Invalid;
+
+        return input_engine->GetUIName(params);
     }
 
     bool IsStickInverted(const Common::ParamPackage& params) {
-        const std::string engine = params.Get("engine", "");
-        if (engine == mouse->GetEngineName()) {
-            return mouse->IsStickInverted(params);
+        const auto input_engine = GetInputEngine(params);
+
+        if (input_engine == nullptr) {
+            return false;
         }
-        if (engine == gcadapter->GetEngineName()) {
-            return gcadapter->IsStickInverted(params);
-        }
-        if (engine == udp_client->GetEngineName()) {
-            return udp_client->IsStickInverted(params);
-        }
-        if (engine == tas_input->GetEngineName()) {
-            return tas_input->IsStickInverted(params);
-        }
-#ifdef HAVE_SDL2
-        if (engine == sdl->GetEngineName()) {
-            return sdl->IsStickInverted(params);
-        }
-#endif
-        return false;
+
+        return input_engine->IsStickInverted(params);
     }
 
     bool IsController(const Common::ParamPackage& params) {
@@ -290,6 +203,9 @@ struct InputSubsystem::Impl {
         if (engine == tas_input->GetEngineName()) {
             return true;
         }
+        if (engine == virtual_gamepad->GetEngineName()) {
+            return true;
+        }
 #ifdef HAVE_SDL2
         if (engine == sdl->GetEngineName()) {
             return true;
@@ -338,28 +254,10 @@ struct InputSubsystem::Impl {
     std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
     std::shared_ptr<Camera> camera;
     std::shared_ptr<VirtualAmiibo> virtual_amiibo;
-
-    std::shared_ptr<InputFactory> keyboard_factory;
-    std::shared_ptr<InputFactory> mouse_factory;
-    std::shared_ptr<InputFactory> gcadapter_input_factory;
-    std::shared_ptr<InputFactory> touch_screen_factory;
-    std::shared_ptr<InputFactory> udp_client_input_factory;
-    std::shared_ptr<InputFactory> tas_input_factory;
-    std::shared_ptr<InputFactory> camera_input_factory;
-    std::shared_ptr<InputFactory> virtual_amiibo_input_factory;
-
-    std::shared_ptr<OutputFactory> keyboard_output_factory;
-    std::shared_ptr<OutputFactory> mouse_output_factory;
-    std::shared_ptr<OutputFactory> gcadapter_output_factory;
-    std::shared_ptr<OutputFactory> udp_client_output_factory;
-    std::shared_ptr<OutputFactory> tas_output_factory;
-    std::shared_ptr<OutputFactory> camera_output_factory;
-    std::shared_ptr<OutputFactory> virtual_amiibo_output_factory;
+    std::shared_ptr<VirtualGamepad> virtual_gamepad;
 
 #ifdef HAVE_SDL2
     std::shared_ptr<SDLDriver> sdl;
-    std::shared_ptr<InputFactory> sdl_input_factory;
-    std::shared_ptr<OutputFactory> sdl_output_factory;
 #endif
 };
 
@@ -423,6 +321,14 @@ const VirtualAmiibo* InputSubsystem::GetVirtualAmiibo() const {
     return impl->virtual_amiibo.get();
 }
 
+VirtualGamepad* InputSubsystem::GetVirtualGamepad() {
+    return impl->virtual_gamepad.get();
+}
+
+const VirtualGamepad* InputSubsystem::GetVirtualGamepad() const {
+    return impl->virtual_gamepad.get();
+}
+
 std::vector<Common::ParamPackage> InputSubsystem::GetInputDevices() const {
     return impl->GetInputDevices();
 }

src/input_common/main.h

@@ -34,6 +34,7 @@ class Keyboard;
 class Mouse;
 class TouchScreen;
 class VirtualAmiibo;
+class VirtualGamepad;
 struct MappingData;
 } // namespace InputCommon
 
@@ -108,6 +109,12 @@ public:
     /// Retrieves the underlying virtual amiibo input device.
     [[nodiscard]] const VirtualAmiibo* GetVirtualAmiibo() const;
 
+    /// Retrieves the underlying virtual gamepad input device.
+    [[nodiscard]] VirtualGamepad* GetVirtualGamepad();
+
+    /// Retrieves the underlying virtual gamepad input device.
+    [[nodiscard]] const VirtualGamepad* GetVirtualGamepad() const;
+
     /**
      * Returns all available input devices that this Factory can create a new device with.
      * Each returned ParamPackage should have a `display` field used for display, a `engine` field

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -461,7 +461,7 @@ void EmitSetSampleMask(EmitContext& ctx, Id value) {
 }
 
 void EmitSetFragDepth(EmitContext& ctx, Id value) {
-    if (!ctx.runtime_info.convert_depth_mode) {
+    if (!ctx.runtime_info.convert_depth_mode || ctx.profile.support_native_ndc) {
         ctx.OpStore(ctx.frag_depth, value);
         return;
     }

src/shader_recompiler/backend/spirv/emit_spirv_special.cpp

@@ -116,7 +116,8 @@ void EmitPrologue(EmitContext& ctx) {
 }
 
 void EmitEpilogue(EmitContext& ctx) {
-    if (ctx.stage == Stage::VertexB && ctx.runtime_info.convert_depth_mode) {
+    if (ctx.stage == Stage::VertexB && ctx.runtime_info.convert_depth_mode &&
+        !ctx.profile.support_native_ndc) {
         ConvertDepthMode(ctx);
     }
     if (ctx.stage == Stage::Fragment) {
@@ -125,7 +126,7 @@ void EmitEpilogue(EmitContext& ctx) {
 }
 
 void EmitEmitVertex(EmitContext& ctx, const IR::Value& stream) {
-    if (ctx.runtime_info.convert_depth_mode) {
+    if (ctx.runtime_info.convert_depth_mode && !ctx.profile.support_native_ndc) {
         ConvertDepthMode(ctx);
     }
     if (stream.IsImmediate()) {

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/shader_recompiler/profile.h

@@ -35,6 +35,7 @@ struct Profile {
     bool support_int64_atomics{};
     bool support_derivative_control{};
     bool support_geometry_shader_passthrough{};
+    bool support_native_ndc{};
     bool support_gl_nv_gpu_shader_5{};
     bool support_gl_amd_gpu_shader_half_float{};
     bool support_gl_texture_shadow_lod{};

src/video_core/CMakeLists.txt

@@ -178,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
@@ -195,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/engines/draw_manager.cpp

@@ -46,21 +46,26 @@ void DrawManager::ProcessMethodCall(u32 method, u32 argument) {
         SetInlineIndexBuffer(regs.inline_index_4x8.index2);
         SetInlineIndexBuffer(regs.inline_index_4x8.index3);
         break;
-    case MAXWELL3D_REG_INDEX(topology_override):
-        use_topology_override = true;
+    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) {
-    maxwell3d->rasterizer->Clear(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)
+    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;
 }
@@ -115,8 +120,9 @@ 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)
+        if (!force_draw) {
             break;
+        }
         [[fallthrough]];
     case DrawMode::General:
         draw_state.base_instance = regs.global_base_instance_index;
@@ -156,25 +162,28 @@ void DrawManager::DrawIndexSmall(u32 argument) {
     ProcessDraw(true, 1);
 }
 
-void DrawManager::ProcessTopologyOverride() {
-    if (!use_topology_override)
-        return;
-
+void DrawManager::UpdateTopology() {
     const auto& regs{maxwell3d->regs};
-    switch (regs.topology_override) {
-    case PrimitiveTopologyOverride::None:
+    switch (regs.primitive_topology_control) {
+    case PrimitiveTopologyControl::UseInBeginMethods:
         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);
+    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;
     }
 }
@@ -183,9 +192,10 @@ 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);
 
-    ProcessTopologyOverride();
+    UpdateTopology();
 
-    if (maxwell3d->ShouldExecute())
+    if (maxwell3d->ShouldExecute()) {
         maxwell3d->rasterizer->Draw(draw_indexed, instance_count);
+    }
 }
 } // namespace Tegra::Engines

src/video_core/engines/draw_manager.h

@@ -10,6 +10,7 @@ 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;
@@ -58,12 +59,11 @@ private:
 
     void DrawIndexSmall(u32 argument);
 
-    void ProcessTopologyOverride();
+    void UpdateTopology();
 
     void ProcessDraw(bool draw_indexed, u32 instance_count);
 
     Maxwell3D* maxwell3d{};
     State draw_state{};
-    bool use_topology_override{};
 };
 } // namespace Tegra::Engines

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/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{};

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -174,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,
 
@@ -203,6 +204,7 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .support_int64_atomics = false,
           .support_derivative_control = device.HasDerivativeControl(),
           .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
+          .support_native_ndc = true,
           .support_gl_nv_gpu_shader_5 = device.HasNvGpuShader5(),
           .support_gl_amd_gpu_shader_half_float = device.HasAmdShaderHalfFloat(),
           .support_gl_texture_shadow_lod = device.HasTextureShadowLod(),
@@ -255,9 +257,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{};
@@ -265,44 +272,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);
@@ -314,6 +326,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();

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/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;