Fix build

Fix for current crash on master.
Just reverted only the necessary stuff so that PresentManager can hold a reference to khr and resist death upon application hold/restore.
@Lizzie shall judge.

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3685
Co-authored-by: xbzk <xbzk@eden-emu.dev>
Co-committed-by: xbzk <xbzk@eden-emu.dev>

src/core/hle/service/prepo/prepo.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -28,8 +28,10 @@ public:
             {10101, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::Old>, "SaveReportWithUserOld"},
             {10102, &PlayReport::SaveReport<Core::Reporter::PlayReportType::Old2>, "SaveReportOld2"},
             {10103, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::Old2>, "SaveReportWithUserOld2"},
-            {10104, &PlayReport::SaveReport<Core::Reporter::PlayReportType::New>, "SaveReport"},
-            {10105, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::New>, "SaveReportWithUser"},
+            {10104, &PlayReport::SaveReport<Core::Reporter::PlayReportType::Old3>, "SaveReportOld3"},
+            {10105, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::Old3>, "SaveReportWithUserOld3"},
+            {10106, &PlayReport::SaveReport<Core::Reporter::PlayReportType::New>, "SaveReport"},
+            {10107, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::New>, "SaveReportWithUser"},
             {10200, &PlayReport::RequestImmediateTransmission, "RequestImmediateTransmission"},
             {10300, &PlayReport::GetTransmissionStatus, "GetTransmissionStatus"},
             {10400, &PlayReport::GetSystemSessionId, "GetSystemSessionId"},

src/core/reporter.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -53,6 +56,7 @@ public:
     enum class PlayReportType {
         Old,
         Old2,
+        Old3,
         New,
         System,
     };

src/qt_common/config/shared_translation.cpp

@@ -425,6 +425,9 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
               "their resolution, details and supported controllers and depending on this setting.\n"
               "Setting to Handheld can help improve performance for low end systems."));
     INSERT(Settings, current_user, QString(), QString());
+    INSERT(Settings, serial_unit, tr("Unit Serial"), QString());
+    INSERT(Settings, serial_battery, tr("Battery Serial"), QString());
+    INSERT(Settings, debug_knobs, tr("Debug knobs"), QString());
 
     // Controls
 

src/video_core/buffer_cache/buffer_cache_base.h

@@ -14,9 +14,12 @@
 #include <mutex>
 #include <numeric>
 #include <span>
-#include <ankerl/unordered_dense.h>
 #include <vector>
 
+#include <ankerl/unordered_dense.h>
+#include <boost/container/static_vector.hpp>
+#include <boost/container/small_vector.hpp>
+
 #include "common/common_types.h"
 #include "common/div_ceil.h"
 #include "common/literals.h"
@@ -94,10 +97,10 @@ static constexpr Binding NULL_BINDING{
 
 template <typename Buffer>
 struct HostBindings {
-    boost::container::small_vector<Buffer*, NUM_VERTEX_BUFFERS> buffers;
-    boost::container::small_vector<u64, NUM_VERTEX_BUFFERS> offsets;
-    boost::container::small_vector<u64, NUM_VERTEX_BUFFERS> sizes;
-    boost::container::small_vector<u64, NUM_VERTEX_BUFFERS> strides;
+    boost::container::static_vector<Buffer*, NUM_VERTEX_BUFFERS> buffers;
+    boost::container::static_vector<u64, NUM_VERTEX_BUFFERS> offsets;
+    boost::container::static_vector<u64, NUM_VERTEX_BUFFERS> sizes;
+    boost::container::static_vector<u64, NUM_VERTEX_BUFFERS> strides;
     u32 min_index{NUM_VERTEX_BUFFERS};
     u32 max_index{0};
 };

src/video_core/control/channel_state.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -19,12 +22,12 @@ ChannelState::ChannelState(s32 bind_id_) : bind_id{bind_id_}, initialized{} {}
 void ChannelState::Init(Core::System& system, GPU& gpu, u64 program_id_) {
     ASSERT(memory_manager);
     program_id = program_id_;
-    dma_pusher = std::make_unique<Tegra::DmaPusher>(system, gpu, *memory_manager, *this);
-    maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, *memory_manager);
-    fermi_2d = std::make_unique<Engines::Fermi2D>(*memory_manager);
-    kepler_compute = std::make_unique<Engines::KeplerCompute>(system, *memory_manager);
-    maxwell_dma = std::make_unique<Engines::MaxwellDMA>(system, *memory_manager);
-    kepler_memory = std::make_unique<Engines::KeplerMemory>(system, *memory_manager);
+    dma_pusher.emplace(system, gpu, *memory_manager, *this);
+    maxwell_3d.emplace(system, *memory_manager);
+    fermi_2d.emplace(*memory_manager);
+    kepler_compute.emplace(system, *memory_manager);
+    maxwell_dma.emplace(system, *memory_manager);
+    kepler_memory.emplace(system, *memory_manager);
     initialized = true;
 }
 

src/video_core/control/channel_state.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -6,6 +9,12 @@
 #include <memory>
 
 #include "common/common_types.h"
+#include "video_core/engines/fermi_2d.h"
+#include "video_core/engines/kepler_memory.h"
+#include "video_core/engines/kepler_compute.h"
+#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/maxwell_dma.h"
+#include "video_core/dma_pusher.h"
 
 namespace Core {
 class System;
@@ -18,49 +27,34 @@ class RasterizerInterface;
 namespace Tegra {
 
 class GPU;
-
-namespace Engines {
-class Puller;
-class Fermi2D;
-class Maxwell3D;
-class MaxwellDMA;
-class KeplerCompute;
-class KeplerMemory;
-} // namespace Engines
-
 class MemoryManager;
-class DmaPusher;
 
 namespace Control {
 
 struct ChannelState {
     explicit ChannelState(s32 bind_id);
-    ChannelState(const ChannelState& state) = delete;
-    ChannelState& operator=(const ChannelState&) = delete;
-    ChannelState(ChannelState&& other) noexcept = default;
-    ChannelState& operator=(ChannelState&& other) noexcept = default;
 
     void Init(Core::System& system, GPU& gpu, u64 program_id);
 
     void BindRasterizer(VideoCore::RasterizerInterface* rasterizer);
 
-    s32 bind_id = -1;
-    u64 program_id = 0;
     /// 3D engine
-    std::unique_ptr<Engines::Maxwell3D> maxwell_3d;
+    std::optional<Engines::Maxwell3D> maxwell_3d;
     /// 2D engine
-    std::unique_ptr<Engines::Fermi2D> fermi_2d;
+    std::optional<Engines::Fermi2D> fermi_2d;
     /// Compute engine
-    std::unique_ptr<Engines::KeplerCompute> kepler_compute;
+    std::optional<Engines::KeplerCompute> kepler_compute;
     /// DMA engine
-    std::unique_ptr<Engines::MaxwellDMA> maxwell_dma;
+    std::optional<Engines::MaxwellDMA> maxwell_dma;
     /// Inline memory engine
-    std::unique_ptr<Engines::KeplerMemory> kepler_memory;
-
+    std::optional<Engines::KeplerMemory> kepler_memory;
+    /// NV01 Timer
+    std::optional<Engines::KeplerMemory> nv01_timer;
+    std::optional<DmaPusher> dma_pusher;
     std::shared_ptr<MemoryManager> memory_manager;
 
-    std::unique_ptr<DmaPusher> dma_pusher;
-
+    s32 bind_id = -1;
+    u64 program_id = 0;
     bool initialized{};
 };
 

src/video_core/engines/engine_interface.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -15,6 +15,7 @@
 namespace Tegra::Engines {
 
 enum class EngineTypes : u32 {
+    Nv01Timer,
     KeplerCompute,
     Maxwell3D,
     Fermi2D,

src/video_core/engines/maxwell_3d.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -26,8 +26,15 @@ namespace Tegra::Engines {
 constexpr u32 MacroRegistersStart = 0xE00;
 
 Maxwell3D::Maxwell3D(Core::System& system_, MemoryManager& memory_manager_)
-    : draw_manager{std::make_unique<DrawManager>(this)}, system{system_},
-      memory_manager{memory_manager_}, macro_engine{GetMacroEngine(*this)}, upload_state{memory_manager, regs.upload} {
+    : draw_manager{std::make_unique<DrawManager>(this)}, system{system_}
+    , memory_manager{memory_manager_}
+#ifdef ARCHITECTURE_x86_64
+    , macro_engine(bool(Settings::values.disable_macro_jit))
+#else
+    , macro_engine(true)
+#endif
+    , upload_state{memory_manager, regs.upload}
+{
     dirty.flags.flip();
     InitializeRegisterDefaults();
     execution_mask.reset();
@@ -328,9 +335,9 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
         shadow_state.shadow_ram_control = static_cast<Regs::ShadowRamControl>(nonshadow_argument);
         return;
     case MAXWELL3D_REG_INDEX(load_mme.instruction_ptr):
-        return macro_engine->ClearCode(regs.load_mme.instruction_ptr);
+        return macro_engine.ClearCode(regs.load_mme.instruction_ptr);
     case MAXWELL3D_REG_INDEX(load_mme.instruction):
-        return macro_engine->AddCode(regs.load_mme.instruction_ptr, argument);
+        return macro_engine.AddCode(regs.load_mme.instruction_ptr, argument);
     case MAXWELL3D_REG_INDEX(load_mme.start_address):
         return ProcessMacroBind(argument);
     case MAXWELL3D_REG_INDEX(falcon[4]):
@@ -398,7 +405,7 @@ void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters)
         ((method - MacroRegistersStart) >> 1) % static_cast<u32>(macro_positions.size());
 
     // Execute the current macro.
-    macro_engine->Execute(macro_positions[entry], parameters);
+    macro_engine.Execute(*this, macro_positions[entry], parameters);
 
     draw_manager->DrawDeferred();
 }
@@ -464,7 +471,7 @@ void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
 }
 
 void Maxwell3D::ProcessMacroUpload(u32 data) {
-    macro_engine->AddCode(regs.load_mme.instruction_ptr++, data);
+    macro_engine.AddCode(regs.load_mme.instruction_ptr++, data);
 }
 
 void Maxwell3D::ProcessMacroBind(u32 data) {

src/video_core/engines/maxwell_3d.h

@@ -2258,7 +2258,7 @@ public:
             /// Returns whether the vertex array specified by index is supposed to be
             /// accessed per instance or not.
             bool IsInstancingEnabled(std::size_t index) const {
-                return is_instanced[index];
+                return bool(is_instanced[index]); //FUCK YOU MSVC
             }
         };
 
@@ -3203,7 +3203,7 @@ private:
     std::vector<u32> macro_params;
 
     /// Interpreter for the macro codes uploaded to the GPU.
-    std::optional<MacroEngine> macro_engine;
+    MacroEngine macro_engine;
 
     Upload::State upload_state;
 

src/video_core/engines/nv01_timer.h

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include "common/bit_field.h"
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/logging/log.h"
+#include "video_core/engines/engine_interface.h"
+#include "video_core/engines/engine_upload.h"
+
+namespace Core {
+class System;
+}
+
+namespace Tegra {
+class MemoryManager;
+}
+
+namespace Tegra::Engines {
+class Nv01Timer final : public EngineInterface {
+public:
+    explicit Nv01Timer(Core::System& system_, MemoryManager& memory_manager)
+        : system{system_}
+    {}
+    ~Nv01Timer() override;
+
+    /// Write the value to the register identified by method.
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override {
+        LOG_DEBUG(HW_GPU, "method={}, argument={}, is_last_call={}", method, method_argument, is_last_call);
+    }
+
+    /// Write multiple values to the register identified by method.
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending) override {
+        LOG_DEBUG(HW_GPU, "method={}, base_start={}, amount={}, pending={}", method, fmt::ptr(base_start), amount, methods_pending);
+    }
+
+    struct Regs {
+        // No fucking idea
+        INSERT_PADDING_BYTES_NOINIT(0x48);
+    } regs{};
+private:
+    void ConsumeSinkImpl() override {}
+    Core::System& system;
+};
+}

src/video_core/engines/puller.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -34,24 +37,22 @@ void Puller::ProcessBindMethod(const MethodCall& method_call) {
     bound_engines[method_call.subchannel] = engine_id;
     switch (engine_id) {
     case EngineID::FERMI_TWOD_A:
-        dma_pusher.BindSubchannel(channel_state.fermi_2d.get(), method_call.subchannel,
-                                  EngineTypes::Fermi2D);
+        dma_pusher.BindSubchannel(&*channel_state.fermi_2d, method_call.subchannel, EngineTypes::Fermi2D);
         break;
     case EngineID::MAXWELL_B:
-        dma_pusher.BindSubchannel(channel_state.maxwell_3d.get(), method_call.subchannel,
-                                  EngineTypes::Maxwell3D);
+        dma_pusher.BindSubchannel(&*channel_state.maxwell_3d, method_call.subchannel, EngineTypes::Maxwell3D);
         break;
     case EngineID::KEPLER_COMPUTE_B:
-        dma_pusher.BindSubchannel(channel_state.kepler_compute.get(), method_call.subchannel,
-                                  EngineTypes::KeplerCompute);
+        dma_pusher.BindSubchannel(&*channel_state.kepler_compute, method_call.subchannel, EngineTypes::KeplerCompute);
         break;
     case EngineID::MAXWELL_DMA_COPY_A:
-        dma_pusher.BindSubchannel(channel_state.maxwell_dma.get(), method_call.subchannel,
-                                  EngineTypes::MaxwellDMA);
+        dma_pusher.BindSubchannel(&*channel_state.maxwell_dma, method_call.subchannel, EngineTypes::MaxwellDMA);
         break;
     case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-        dma_pusher.BindSubchannel(channel_state.kepler_memory.get(), method_call.subchannel,
-                                  EngineTypes::KeplerMemory);
+        dma_pusher.BindSubchannel(&*channel_state.kepler_memory, method_call.subchannel, EngineTypes::KeplerMemory);
+        break;
+    case EngineID::NV01_TIMER:
+        dma_pusher.BindSubchannel(&*channel_state.nv01_timer, method_call.subchannel, EngineTypes::Nv01Timer);
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine {:04X}", engine_id);
@@ -209,24 +210,22 @@ void Puller::CallEngineMethod(const MethodCall& method_call) {
 
     switch (engine) {
     case EngineID::FERMI_TWOD_A:
-        channel_state.fermi_2d->CallMethod(method_call.method, method_call.argument,
-                                           method_call.IsLastCall());
+        channel_state.fermi_2d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::MAXWELL_B:
-        channel_state.maxwell_3d->CallMethod(method_call.method, method_call.argument,
-                                             method_call.IsLastCall());
+        channel_state.maxwell_3d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::KEPLER_COMPUTE_B:
-        channel_state.kepler_compute->CallMethod(method_call.method, method_call.argument,
-                                                 method_call.IsLastCall());
+        channel_state.kepler_compute->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::MAXWELL_DMA_COPY_A:
-        channel_state.maxwell_dma->CallMethod(method_call.method, method_call.argument,
-                                              method_call.IsLastCall());
+        channel_state.maxwell_dma->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-        channel_state.kepler_memory->CallMethod(method_call.method, method_call.argument,
-                                                method_call.IsLastCall());
+        channel_state.kepler_memory->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        break;
+    case EngineID::NV01_TIMER:
+        channel_state.nv01_timer->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine");
@@ -255,6 +254,9 @@ void Puller::CallEngineMultiMethod(u32 method, u32 subchannel, const u32* base_s
     case EngineID::KEPLER_INLINE_TO_MEMORY_B:
         channel_state.kepler_memory->CallMultiMethod(method, base_start, amount, methods_pending);
         break;
+    case EngineID::NV01_TIMER:
+        channel_state.nv01_timer->CallMultiMethod(method, base_start, amount, methods_pending);
+        break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine");
         break;

src/video_core/engines/puller.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -20,6 +23,7 @@ class MemoryManager;
 class DmaPusher;
 
 enum class EngineID {
+    NV01_TIMER = 0x0004,
     FERMI_TWOD_A = 0x902D, // 2D Engine
     MAXWELL_B = 0xB197,    // 3D Engine
     KEPLER_COMPUTE_B = 0xB1C0,

src/video_core/macro.h

@@ -7,8 +7,10 @@
 #pragma once
 
 #include <memory>
-#include <ankerl/unordered_dense.h>
+#include <span>
+#include <variant>
 #include <vector>
+#include <ankerl/unordered_dense.h>
 #include "common/bit_field.h"
 #include "common/common_types.h"
 
@@ -98,62 +100,142 @@ union MethodAddress {
 
 } // namespace Macro
 
-class CachedMacro {
-public:
-    CachedMacro(Engines::Maxwell3D& maxwell3d_)
-        : maxwell3d{maxwell3d_}
-    {}
-    virtual ~CachedMacro() = default;
+struct HLEMacro {
+};
+/// @note: these macros have two versions, a normal and extended version, with the extended version
+/// also assigning the base vertex/instance.
+struct HLE_DrawArraysIndirect final {
+    HLE_DrawArraysIndirect(bool extended_) noexcept : extended{extended_} {}
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+    void Fallback(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters);
+    bool extended;
+};
+/// @note: these macros have two versions, a normal and extended version, with the extended version
+/// also assigning the base vertex/instance.
+struct HLE_DrawIndexedIndirect final {
+    explicit HLE_DrawIndexedIndirect(bool extended_) noexcept : extended{extended_} {}
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+    void Fallback(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters);
+    bool extended;
+};
+struct HLE_MultiLayerClear final {
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+};
+struct HLE_MultiDrawIndexedIndirectCount final {
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+    void Fallback(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters);
+};
+struct HLE_DrawIndirectByteCount final {
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+    void Fallback(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters);
+};
+struct HLE_C713C83D8F63CCF3 final {
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+};
+struct HLE_D7333D26E0A93EDE final {
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+};
+struct HLE_BindShader final {
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+};
+struct HLE_SetRasterBoundingBox final {
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+};
+struct HLE_ClearConstBuffer final {
+    HLE_ClearConstBuffer(size_t base_size_) noexcept : base_size{base_size_} {}
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+    size_t base_size;
+};
+struct HLE_ClearMemory final {
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+    std::vector<u32> zero_memory;
+};
+struct HLE_TransformFeedbackSetup final {
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method);
+};
+struct MacroInterpreterImpl final {
+    MacroInterpreterImpl() {}
+    MacroInterpreterImpl(std::span<const u32> code_) : code{code_} {}
+    void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> params, u32 method);
+    void Reset();
+    bool Step(Engines::Maxwell3D& maxwell3d, bool is_delay_slot);
+    u32 GetALUResult(Macro::ALUOperation operation, u32 src_a, u32 src_b);
+    void ProcessResult(Engines::Maxwell3D& maxwell3d, Macro::ResultOperation operation, u32 reg, u32 result);
+    bool EvaluateBranchCondition(Macro::BranchCondition cond, u32 value) const;
+    Macro::Opcode GetOpcode() const;
+    u32 GetRegister(u32 register_id) const;
+    void SetRegister(u32 register_id, u32 value);
+    /// Sets the method address to use for the next Send instruction.
+    [[nodiscard]] inline void SetMethodAddress(u32 address) noexcept {
+        method_address.raw = address;
+    }
+    void Send(Engines::Maxwell3D& maxwell3d, u32 value);
+    u32 Read(Engines::Maxwell3D& maxwell3d, u32 method) const;
+    u32 FetchParameter();
+    /// General purpose macro registers.
+    std::array<u32, Macro::NUM_MACRO_REGISTERS> registers = {};
+    /// Input parameters of the current macro.
+    std::vector<u32> parameters;
+    std::span<const u32> code;
+    /// Program counter to execute at after the delay slot is executed.
+    std::optional<u32> delayed_pc;
+    /// Method address to use for the next Send instruction.
+    Macro::MethodAddress method_address = {};
+    /// Current program counter
+    u32 pc{};
+    /// Index of the next parameter that will be fetched by the 'parm' instruction.
+    u32 next_parameter_index = 0;
+    bool carry_flag = false;
+};
+struct DynamicCachedMacro {
+    virtual ~DynamicCachedMacro() = default;
     /// Executes the macro code with the specified input parameters.
     /// @param parameters The parameters of the macro
     /// @param method     The method to execute
-    virtual void Execute(const std::vector<u32>& parameters, u32 method) = 0;
-    Engines::Maxwell3D& maxwell3d;
+    virtual void Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, u32 method) = 0;
 };
 
-class HLEMacro {
-public:
-    explicit HLEMacro(Engines::Maxwell3D& maxwell3d_);
-    ~HLEMacro();
-    // Allocates and returns a cached macro if the hash matches a known function.
-    // Returns nullptr otherwise.
-    [[nodiscard]] std::unique_ptr<CachedMacro> GetHLEProgram(u64 hash) const;
-private:
-    Engines::Maxwell3D& maxwell3d;
-};
-
-class MacroEngine {
-public:
-    explicit MacroEngine(Engines::Maxwell3D& maxwell3d, bool is_interpreted);
-    ~MacroEngine();
+using AnyCachedMacro = std::variant<
+    std::monostate,
+    HLEMacro,
+    HLE_DrawArraysIndirect,
+    HLE_DrawIndexedIndirect,
+    HLE_MultiDrawIndexedIndirectCount,
+    HLE_MultiLayerClear,
+    HLE_C713C83D8F63CCF3,
+    HLE_D7333D26E0A93EDE,
+    HLE_BindShader,
+    HLE_SetRasterBoundingBox,
+    HLE_ClearConstBuffer,
+    HLE_ClearMemory,
+    HLE_TransformFeedbackSetup,
+    HLE_DrawIndirectByteCount,
+    MacroInterpreterImpl,
+    // Used for JIT x86 macro
+    std::unique_ptr<DynamicCachedMacro>
+>;
 
+struct MacroEngine {
+    MacroEngine(bool is_interpreted_) noexcept : is_interpreted{is_interpreted_} {}
     // Store the uploaded macro code to compile them when they're called.
-    void AddCode(u32 method, u32 data);
-
+    inline void AddCode(u32 method, u32 data) noexcept {
+        uploaded_macro_code[method].push_back(data);
+    }
     // Clear the code associated with a method.
-    void ClearCode(u32 method);
-
+    inline void ClearCode(u32 method) noexcept {
+        macro_cache.erase(method);
+        uploaded_macro_code.erase(method);
+    }
     // Compiles the macro if its not in the cache, and executes the compiled macro
-    void Execute(u32 method, const std::vector<u32>& parameters);
-
-protected:
-    std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code);
-
-private:
+    void Execute(Engines::Maxwell3D& maxwell3d, u32 method, std::span<const u32> parameters);
+    AnyCachedMacro Compile(Engines::Maxwell3D& maxwell3d, std::span<const u32> code);
     struct CacheInfo {
-        std::unique_ptr<CachedMacro> lle_program{};
-        std::unique_ptr<CachedMacro> hle_program{};
+        AnyCachedMacro program;
         u64 hash{};
-        bool has_hle_program{};
     };
-
     ankerl::unordered_dense::map<u32, CacheInfo> macro_cache;
     ankerl::unordered_dense::map<u32, std::vector<u32>> uploaded_macro_code;
-    std::optional<HLEMacro> hle_macros;
-    Engines::Maxwell3D& maxwell3d;
     bool is_interpreted;
 };
 
-std::optional<MacroEngine> GetMacroEngine(Engines::Maxwell3D& maxwell3d);
-
 } // namespace Tegra

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -137,7 +137,7 @@ try
                       memory_allocator,
                       scheduler,
                       swapchain,
-                      *surface)
+                      surface)
     , blit_swapchain(device_memory,
                    device,
                    memory_allocator,

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -10,6 +10,7 @@
 #include <span>
 #include <vector>
 
+#include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
@@ -583,18 +584,18 @@ void BufferCacheRuntime::BindVertexBuffer(u32 index, VkBuffer buffer, u32 offset
 }
 
 void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bindings) {
-    boost::container::small_vector<VkBuffer, 32> buffer_handles;
-    for (u32 index = 0; index < bindings.buffers.size(); ++index) {
-        auto handle = bindings.buffers[index]->Handle();
+    boost::container::static_vector<VkBuffer, VideoCommon::NUM_VERTEX_BUFFERS> buffer_handles(bindings.buffers.size());
+    for (u32 i = 0; i < bindings.buffers.size(); ++i) {
+        auto handle = bindings.buffers[i]->Handle();
         if (handle == VK_NULL_HANDLE) {
-            bindings.offsets[index] = 0;
-            bindings.sizes[index] = VK_WHOLE_SIZE;
+            bindings.offsets[i] = 0;
+            bindings.sizes[i] = VK_WHOLE_SIZE;
             if (!device.HasNullDescriptor()) {
                 ReserveNullBuffer();
                 handle = *null_buffer;
             }
         }
-        buffer_handles.push_back(handle);
+        buffer_handles[i] = handle;
     }
     const u32 device_max = device.GetMaxVertexInputBindings();
     const u32 min_binding = (std::min)(bindings.min_index, device_max);
@@ -604,19 +605,12 @@ void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bi
         return;
     }
     if (device.IsExtExtendedDynamicStateSupported()) {
-        scheduler.Record([bindings_ = std::move(bindings),
-                          buffer_handles_ = std::move(buffer_handles),
-                          binding_count](vk::CommandBuffer cmdbuf) {
-            cmdbuf.BindVertexBuffers2EXT(bindings_.min_index, binding_count, buffer_handles_.data(),
-                                         bindings_.offsets.data(), bindings_.sizes.data(),
-                                         bindings_.strides.data());
+        scheduler.Record([bindings_ = std::move(bindings), buffer_handles_ = std::move(buffer_handles), binding_count](vk::CommandBuffer cmdbuf) {
+            cmdbuf.BindVertexBuffers2EXT(bindings_.min_index, binding_count, buffer_handles_.data(), bindings_.offsets.data(), bindings_.sizes.data(), bindings_.strides.data());
         });
     } else {
-        scheduler.Record([bindings_ = std::move(bindings),
-                          buffer_handles_ = std::move(buffer_handles),
-                          binding_count](vk::CommandBuffer cmdbuf) {
-            cmdbuf.BindVertexBuffers(bindings_.min_index, binding_count, buffer_handles_.data(),
-                                     bindings_.offsets.data());
+        scheduler.Record([bindings_ = std::move(bindings), buffer_handles_ = std::move(buffer_handles), binding_count](vk::CommandBuffer cmdbuf) {
+            cmdbuf.BindVertexBuffers(bindings_.min_index, binding_count, buffer_handles_.data(), bindings_.offsets.data());
         });
     }
 }
@@ -647,15 +641,21 @@ void BufferCacheRuntime::BindTransformFeedbackBuffers(VideoCommon::HostBindings<
         // Already logged in the rasterizer
         return;
     }
-    boost::container::small_vector<VkBuffer, 4> buffer_handles;
-    for (u32 index = 0; index < bindings.buffers.size(); ++index) {
-        buffer_handles.push_back(bindings.buffers[index]->Handle());
+    boost::container::static_vector<VkBuffer, VideoCommon::NUM_VERTEX_BUFFERS> buffer_handles(bindings.buffers.size());
+    for (u32 i = 0; i < bindings.buffers.size(); ++i) {
+        auto handle = bindings.buffers[i]->Handle();
+        if (handle == VK_NULL_HANDLE) {
+            bindings.offsets[i] = 0;
+            bindings.sizes[i] = VK_WHOLE_SIZE;
+            if (!device.HasNullDescriptor()) {
+                ReserveNullBuffer();
+                handle = *null_buffer;
+            }
+        }
+        buffer_handles[i] = handle;
     }
-    scheduler.Record([bindings_ = std::move(bindings),
-                      buffer_handles_ = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
-        cmdbuf.BindTransformFeedbackBuffersEXT(0, static_cast<u32>(buffer_handles_.size()),
-                                               buffer_handles_.data(), bindings_.offsets.data(),
-                                               bindings_.sizes.data());
+    scheduler.Record([bindings_ = std::move(bindings), buffer_handles_ = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
+        cmdbuf.BindTransformFeedbackBuffersEXT(0, u32(buffer_handles_.size()), buffer_handles_.data(), bindings_.offsets.data(), bindings_.sizes.data());
     });
 }
 

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -101,7 +101,7 @@ PresentManager::PresentManager(const vk::Instance& instance_,
                                MemoryAllocator& memory_allocator_,
                                Scheduler& scheduler_,
                                Swapchain& swapchain_,
-                               VkSurfaceKHR_T* surface_)
+                               vk::SurfaceKHR& surface_)
     : instance{instance_}
     , render_window{render_window_}
     , device{device_}
@@ -291,7 +291,7 @@ void PresentManager::PresentThread(std::stop_token token) {
 }
 
 void PresentManager::RecreateSwapchain(Frame* frame) {
-    swapchain.Create(surface, frame->width, frame->height); // Pass raw pointer
+    swapchain.Create(*surface, frame->width, frame->height); // Pass raw pointer
     SetImageCount();
 }
 
@@ -310,7 +310,7 @@ void PresentManager::CopyToSwapchain(Frame* frame) {
             // Recreate surface and swapchain if needed.
             if (requires_recreation) {
 #ifdef ANDROID
-                surface = *CreateSurface(instance, render_window.GetWindowInfo()).address();
+                surface = CreateSurface(instance, render_window.GetWindowInfo());
 #endif
                 RecreateSwapchain(frame);
             }

src/video_core/renderer_vulkan/vk_present_manager.h

@@ -44,7 +44,7 @@ public:
                    MemoryAllocator& memory_allocator,
                    Scheduler& scheduler,
                    Swapchain& swapchain,
-                   VkSurfaceKHR_T* surface);
+                   vk::SurfaceKHR& surface);
     ~PresentManager();
 
     /// Returns the last used presentation frame
@@ -78,7 +78,7 @@ private:
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;
     Swapchain& swapchain;
-    VkSurfaceKHR_T* surface;
+    vk::SurfaceKHR& surface;
     vk::CommandPool cmdpool;
     std::vector<Frame> frames;
     boost::container::deque<Frame*> present_queue;

src/video_core/texture_cache/texture_cache.h

@@ -70,14 +70,10 @@ TextureCache<P>::TextureCache(Runtime& runtime_, Tegra::MaxwellDeviceMemoryManag
             (std::max)((std::min)(device_local_memory - min_vacancy_critical, min_spacing_critical),
                      DEFAULT_CRITICAL_MEMORY));
         minimum_memory = static_cast<u64>((device_local_memory - mem_threshold) / 2);
-
-        lowmemorydevice = false;
     } else {
         expected_memory = DEFAULT_EXPECTED_MEMORY + 512_MiB;
         critical_memory = DEFAULT_CRITICAL_MEMORY + 1_GiB;
         minimum_memory = 0;
-
-        lowmemorydevice = true;
     }
 
     const bool gpu_unswizzle_enabled = Settings::values.gpu_unswizzle_enabled.GetValue();
@@ -122,102 +118,46 @@ void TextureCache<P>::RunGarbageCollector() {
     bool aggressive_mode = false;
     u64 ticks_to_destroy = 0;
     size_t num_iterations = 0;
-
     const auto Configure = [&](bool allow_aggressive) {
         high_priority_mode = total_used_memory >= expected_memory;
         aggressive_mode = allow_aggressive && total_used_memory >= critical_memory;
         ticks_to_destroy = aggressive_mode ? 10ULL : high_priority_mode ? 25ULL : 50ULL;
         num_iterations = aggressive_mode ? 40 : (high_priority_mode ? 20 : 10);
     };
-
-    const auto Cleanup = [this, &num_iterations, &high_priority_mode,
-                          &aggressive_mode](ImageId image_id) {
+    const auto Cleanup = [this, &num_iterations, &high_priority_mode, &aggressive_mode](ImageId image_id) {
         if (num_iterations == 0) {
             return true;
         }
         --num_iterations;
         auto& image = slot_images[image_id];
-
-        // Never delete recently allocated sparse textures (within 3 frames)
-        const bool is_recently_allocated = image.allocation_tick >= frame_tick - 3;
-        if (is_recently_allocated && image.info.is_sparse) {
-            return false;
-        }
-
         if (True(image.flags & ImageFlagBits::IsDecoding)) {
-            // This image is still being decoded, deleting it will invalidate the slot
-            // used by the async decoder thread.
             return false;
         }
-
-        // Prioritize large sparse textures for cleanup
-        const bool is_large_sparse = lowmemorydevice &&
-                                     image.info.is_sparse &&
-                                     image.guest_size_bytes >= 256_MiB;
-
-        if (!aggressive_mode && !is_large_sparse &&
-            True(image.flags & ImageFlagBits::CostlyLoad)) {
-            return false;
-        }
-
-        const bool must_download =
-            image.IsSafeDownload() && False(image.flags & ImageFlagBits::BadOverlap);
-        if (!high_priority_mode && !is_large_sparse && must_download) {
-            return false;
-        }
-
-        if (must_download && !is_large_sparse) {
+        const bool must_download = image.IsSafeDownload() && False(image.flags & ImageFlagBits::BadOverlap);
+        if (must_download && !image.info.is_sparse) {
             auto map = runtime.DownloadStagingBuffer(image.unswizzled_size_bytes);
             const auto copies = FixSmallVectorADL(FullDownloadCopies(image.info));
             image.DownloadMemory(map, copies);
             runtime.Finish();
-            SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, map.mapped_span,
-                         swizzle_data_buffer);
+            SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, map.mapped_span, swizzle_data_buffer);
         }
-
         if (True(image.flags & ImageFlagBits::Tracked)) {
             UntrackImage(image, image_id);
         }
         UnregisterImage(image_id);
-        DeleteImage(image_id, image.scale_tick > frame_tick + 5);
-
-        if (total_used_memory < critical_memory) {
-            if (aggressive_mode) {
-                // Sink the aggresiveness.
-                num_iterations >>= 2;
-                aggressive_mode = false;
-                return false;
-            }
-            if (high_priority_mode && total_used_memory < expected_memory) {
-                num_iterations >>= 1;
-                high_priority_mode = false;
-            }
+        DeleteImage(image_id, image.scale_tick > frame_tick + 10 || aggressive_mode);
+        if (aggressive_mode && total_used_memory < critical_memory) {
+            num_iterations >>= 2;
+            aggressive_mode = false;
+        }
+        if (high_priority_mode && total_used_memory < expected_memory) {
+            num_iterations >>= 1;
+            high_priority_mode = false;
         }
         return false;
     };
-
-    // Aggressively clear massive sparse textures
-    if (total_used_memory >= expected_memory) {
-        lru_cache.ForEachItemBelow(frame_tick, [&](ImageId image_id) {
-            auto& image = slot_images[image_id];
-            // Only target sparse textures that are old enough
-            if (lowmemorydevice &&
-                image.info.is_sparse &&
-                image.guest_size_bytes >= 256_MiB &&
-                image.allocation_tick < frame_tick - 3) {
-                LOG_DEBUG(HW_GPU, "GC targeting old sparse texture at 0x{:X} ({} MiB, age: {} frames)",
-                         image.gpu_addr, image.guest_size_bytes / (1024 * 1024),
-                         frame_tick - image.allocation_tick);
-                return Cleanup(image_id);
-            }
-            return false;
-        });
-    }
-
     Configure(false);
     lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, Cleanup);
-
-    // If pressure is still too high, prune aggressively.
     if (total_used_memory >= critical_memory) {
         Configure(true);
         lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, Cleanup);
@@ -1196,9 +1136,6 @@ void TextureCache<P>::RefreshContents(Image& image, ImageId image_id) {
     }
 
     image.flags &= ~ImageFlagBits::CpuModified;
-    if( lowmemorydevice && image.info.format == PixelFormat::BC1_RGBA_UNORM && MapSizeBytes(image) >= 256_MiB ) {
-        return;
-    }
 
     TrackImage(image, image_id);
 
@@ -1619,39 +1556,6 @@ ImageId TextureCache<P>::InsertImage(const ImageInfo& info, GPUVAddr gpu_addr,
         }
     }
     ASSERT_MSG(cpu_addr, "Tried to insert an image to an invalid gpu_addr=0x{:x}", gpu_addr);
-
-    // For large sparse textures, aggressively clean up old allocations at same address
-    if (lowmemorydevice && info.is_sparse && CalculateGuestSizeInBytes(info) >= 256_MiB) {
-        const auto alloc_it = image_allocs_table.find(gpu_addr);
-        if (alloc_it != image_allocs_table.end()) {
-            const ImageAllocId alloc_id = alloc_it->second;
-            auto& alloc_images = slot_image_allocs[alloc_id].images;
-
-            // Collect old images at this address that were created more than 2 frames ago
-            boost::container::small_vector<ImageId, 4> to_delete;
-            for (ImageId old_image_id : alloc_images) {
-                Image& old_image = slot_images[old_image_id];
-                if (old_image.info.is_sparse &&
-                    old_image.gpu_addr == gpu_addr &&
-                    old_image.allocation_tick < frame_tick - 2) {  // Try not to delete fresh textures
-                    to_delete.push_back(old_image_id);
-                }
-            }
-
-            // Delete old images immediately
-            for (ImageId old_id : to_delete) {
-                Image& old_image = slot_images[old_id];
-                LOG_DEBUG(HW_GPU, "Immediately deleting old sparse texture at 0x{:X} ({} MiB)",
-                         gpu_addr, old_image.guest_size_bytes / (1024 * 1024));
-                if (True(old_image.flags & ImageFlagBits::Tracked)) {
-                    UntrackImage(old_image, old_id);
-                }
-                UnregisterImage(old_id);
-                DeleteImage(old_id, true);
-            }
-        }
-    }
-
     const ImageId image_id = JoinImages(info, gpu_addr, *cpu_addr);
     const Image& image = slot_images[image_id];
     // Using "image.gpu_addr" instead of "gpu_addr" is important because it might be different
@@ -1667,27 +1571,6 @@ template <class P>
 ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DAddr cpu_addr) {
     ImageInfo new_info = info;
     const size_t size_bytes = CalculateGuestSizeInBytes(new_info);
-
-    // Proactive cleanup for large sparse texture allocations
-    if (lowmemorydevice && new_info.is_sparse && size_bytes >= 256_MiB) {
-        const u64 estimated_alloc_size = size_bytes;
-
-        if (total_used_memory + estimated_alloc_size >= critical_memory) {
-            LOG_DEBUG(HW_GPU, "Large sparse texture allocation ({} MiB) - running aggressive GC. "
-                       "Current memory: {} MiB, Critical: {} MiB",
-                       size_bytes / (1024 * 1024),
-                       total_used_memory / (1024 * 1024),
-                       critical_memory / (1024 * 1024));
-            RunGarbageCollector();
-
-            // If still over threshold after GC, try one more aggressive pass
-            if (total_used_memory + estimated_alloc_size >= critical_memory) {
-                LOG_DEBUG(HW_GPU, "Still critically low on memory, running second GC pass");
-                RunGarbageCollector();
-            }
-        }
-    }
-
     const bool broken_views = runtime.HasBrokenTextureViewFormats();
     const bool native_bgr = runtime.HasNativeBgr();
     join_overlap_ids.clear();

src/video_core/texture_cache/texture_cache_base.h

@@ -478,7 +478,6 @@ private:
     u64 minimum_memory;
     u64 expected_memory;
     u64 critical_memory;
-    bool lowmemorydevice = false;
     size_t gpu_unswizzle_maxsize = 0;
     size_t swizzle_chunk_size = 0;
     u32 swizzle_slices_per_batch = 0;

src/yuzu/configuration/configure_per_game_addons.cpp

@@ -10,13 +10,14 @@
 
 #include <fmt/format.h>
 
+#include <QDesktopServices>
 #include <QHeaderView>
 #include <QMenu>
 #include <QStandardItemModel>
+#include <QStandardPaths>
 #include <QString>
 #include <QTimer>
 #include <QTreeView>
-#include <QStandardPaths>
 
 #include "common/common_types.h"
 #include "common/fs/fs.h"
@@ -42,7 +43,7 @@ ConfigurePerGameAddons::ConfigurePerGameAddons(Core::System& system_, QWidget* p
     item_model = new QStandardItemModel(tree_view);
     tree_view->setModel(item_model);
     tree_view->setAlternatingRowColors(true);
-    tree_view->setSelectionMode(QHeaderView::MultiSelection);
+    tree_view->setSelectionMode(QHeaderView::ExtendedSelection);
     tree_view->setSelectionBehavior(QHeaderView::SelectRows);
     tree_view->setVerticalScrollMode(QHeaderView::ScrollPerPixel);
     tree_view->setHorizontalScrollMode(QHeaderView::ScrollPerPixel);
@@ -248,8 +249,11 @@ void ConfigurePerGameAddons::AddonDeleteRequested(QList<QModelIndex> selected) {
 
 void ConfigurePerGameAddons::showContextMenu(const QPoint& pos) {
     const QModelIndex index = tree_view->indexAt(pos);
-    auto selected = tree_view->selectionModel()->selectedIndexes();
-    if (index.isValid() && selected.empty()) selected = {index};
+    auto selected = tree_view->selectionModel()->selectedRows();
+    if (index.isValid() && selected.empty()) {
+        QModelIndex idx = item_model->index(index.row(), 0);
+        if (idx.isValid()) selected << idx;
+    }
 
     if (selected.empty()) return;
 
@@ -260,6 +264,15 @@ void ConfigurePerGameAddons::showContextMenu(const QPoint& pos) {
         AddonDeleteRequested(selected);
     });
 
+    if (selected.length() == 1) {
+        auto loc = selected.at(0).data(PATCH_LOCATION).toString();
+        if (QFileInfo::exists(loc)) {
+            QAction* open = menu.addAction(tr("&Open in File Manager"));
+            connect(open, &QAction::triggered, this,
+                    [selected, loc]() { QDesktopServices::openUrl(QUrl::fromLocalFile(loc)); });
+        }
+    }
+
     menu.exec(tree_view->viewport()->mapToGlobal(pos));
 }