[core, hle, video_core, memory] Improve multi-process, display layers, dynamic shader cache and rework overlay (#4238)

- [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions).
- [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md)
- [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability.

-------------------

- Dynamic shader cache reloading capability for qlaunch
- Multi-process improvements (thanks to @frank1734), instead of just using the main application we now respect caller process (also did it for HID devices while I was at it)
- Layer stack masks & shared buffer screenshot for video core, added different masks (screenshot, recording, etc.) this was discovered as an issue due to how in qlaunch the transition was not right between applications. May not be perfect but also fixes screenshots while using qlaunch
- Reworked overlay display management (input and visibility) - instead of random numbers as I've previously did, I decided to add an AppletZIndex enum for better readability. Also split capability of input by touch and gamepad.
- etc.

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4238
Reviewed-by: Samuel <lizzie@eden-emu.dev>
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
Reviewed-by: MaranBr <maranbr@eden-emu.dev>

src/android/app/src/main/jni/native.cpp

@@ -76,6 +76,7 @@ extern "C" {
 #include "core/frontend/applets/software_keyboard.h"
 #include "core/frontend/applets/web_browser.h"
 #include "common/android/applets/web_browser.h"
+#include "core/file_sys/common_funcs.h"
 #include "core/hle/service/am/applet_manager.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/filesystem/filesystem.h"
@@ -311,11 +312,23 @@ Core::SystemResultStatus EmulationSession::InitializeEmulation(const std::string
     ConfigureFilesystemProvider(filepath);
 
     // Load the ROM.
+    const u64 previous_program_id =
+        program_index != 0 && m_next_program_id.load() >
+                                  static_cast<u64>(Service::AM::AppletProgramId::MaxProgramId)
+            ? m_next_program_id.load()
+            : 0;
+
     Service::AM::FrontendAppletParameters params{
+        .program_id = previous_program_id,
         .applet_id = static_cast<Service::AM::AppletId>(m_applet_id),
         .launch_type = frontend_initiated ? Service::AM::LaunchType::FrontendInitiated
                                           : Service::AM::LaunchType::ApplicationInitiated,
         .program_index = static_cast<s32>(program_index),
+        .previous_program_index =
+            previous_program_id != 0
+                ? static_cast<s32>(previous_program_id -
+                                   FileSys::GetBaseTitleID(previous_program_id))
+                : -1,
     };
 
     m_load_result = m_system.Load(EmulationSession::GetInstance().Window(), filepath, params);
@@ -328,8 +341,12 @@ Core::SystemResultStatus EmulationSession::InitializeEmulation(const std::string
     m_system.GetCpuManager().OnGpuReady();
     m_system.RegisterExitCallback([&] { HaltEmulation(); });
 
+    m_system.RegisterApplicationChangedCallback(
+        [&](u64 changed_program_id) { RequestDiskShaderCacheReload(changed_program_id); });
+
     // Register an ExecuteProgram callback such that Core can execute a sub-program
     m_system.RegisterExecuteProgramCallback([&](std::size_t program_index_) {
+        m_next_program_id = m_system.GetApplicationProcessProgramID();
         m_next_program_index = program_index_;
         EmulationSession::GetInstance().HaltEmulation();
     });
@@ -407,20 +424,58 @@ void EmulationSession::RunEmulation() {
     }
 
     while (true) {
+        std::optional<u64> reload_title;
         {
             [[maybe_unused]] std::unique_lock lock(m_mutex);
-            if (m_cv.wait_for(lock, std::chrono::milliseconds(800),
-                              [&]() { return !m_is_running; })) {
-                // Emulation halted.
-                break;
+            if (m_cv.wait_for(lock, std::chrono::milliseconds(800), [&]() {
+                    return !m_is_running || m_pending_shader_cache_title.has_value();
+                })) {
+                if (!m_is_running) {
+                    break;
+                }
+                reload_title = std::exchange(m_pending_shader_cache_title, std::nullopt);
             }
         }
+
+        if (reload_title.has_value())
+            ReloadDiskShaderCache(*reload_title);
     }
 
     // Reset current applet ID.
     m_applet_id = static_cast<int>(Service::AM::AppletId::Application);
 }
 
+void EmulationSession::RequestDiskShaderCacheReload(u64 program_id) {
+    {
+        std::scoped_lock lock(m_mutex);
+        m_pending_shader_cache_title = program_id;
+    }
+    m_cv.notify_one();
+}
+
+void EmulationSession::ReloadDiskShaderCache(u64 program_id) {
+    if (!Settings::values.use_disk_shader_cache.GetValue())
+        return;
+
+    LOG_INFO(Frontend, "Reloading disk shader cache for {:016X}", program_id);
+
+    const bool was_paused = m_is_paused;
+
+    m_system.Pause();
+    m_system.GPU().WaitForIdle();
+    m_system.GPU().ObtainContext();
+
+    LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
+    m_system.Renderer().ReadRasterizer()->LoadDiskResources(program_id, std::stop_token{},
+                                                            LoadDiskCacheProgress);
+    LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Complete, 0, 0);
+
+    m_system.GPU().ReleaseContext();
+
+    if (!was_paused)
+        m_system.Run();
+}
+
 Common::Android::SoftwareKeyboard::AndroidKeyboard* EmulationSession::SoftwareKeyboard() {
     return m_software_keyboard;
 }

src/android/app/src/main/jni/native.h

@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <optional>
+
 #include <android/native_window_jni.h>
 #include "common/android/applets/software_keyboard.h"
 #include "core/core.h"
@@ -44,6 +46,7 @@ public:
     void HaltEmulation();
     void RunEmulation();
     void ShutdownEmulation();
+    void RequestDiskShaderCacheReload(u64 program_id);
 
     const Core::PerfStatsResults& PerfStats();
     int ShadersBuilding();
@@ -65,6 +68,7 @@ private:
     static void LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress, int max);
     static void OnEmulationStopped(Core::SystemResultStatus result);
     static void ChangeProgram(std::size_t program_index);
+    void ReloadDiskShaderCache(u64 program_id);
 
 private:
     // Window management
@@ -83,6 +87,7 @@ private:
     Common::Android::SoftwareKeyboard::AndroidKeyboard* m_software_keyboard{};
     std::unique_ptr<FileSys::ManualContentProvider> m_manual_provider;
     int m_applet_id{1};
+    std::optional<u64> m_pending_shader_cache_title;
 
     // GPU driver parameters
     std::shared_ptr<Common::DynamicLibrary> m_vulkan_library;
@@ -93,4 +98,5 @@ private:
 
     // Program index for next boot
     std::atomic<s32> m_next_program_index = -1;
+    std::atomic<u64> m_next_program_id = 0;
 };

src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,13 +10,12 @@
 namespace AudioCore::ADSP::OpusDecoder {
 
 namespace {
-bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
-}
+constexpr u32 OpusStreamCountMax = 255;
 
 bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
-    return total_stream_count > 0 && static_cast<s32>(stereo_stream_count) >= 0 &&
-           stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);
+    return total_stream_count > 0 && total_stream_count <= OpusStreamCountMax &&
+           static_cast<s32>(stereo_stream_count) >= 0 &&
+           stereo_stream_count <= total_stream_count;
 }
 } // namespace
 

src/audio_core/opus/hardware_opus.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -105,7 +108,7 @@ Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 chan
     shared_memory.host_send_data[4] = total_stream_count;
     shared_memory.host_send_data[5] = stereo_stream_count;
 
-    ASSERT(channel_count <= MaxChannels);
+    ASSERT(channel_count <= shared_memory.channel_mapping.size());
     std::memcpy(shared_memory.channel_mapping.data(), mappings, channel_count * sizeof(u8));
 
     opus_decoder.Send(ADSP::Direction::DSP,

src/core/core.cpp

@@ -295,6 +295,10 @@ struct System::Impl {
     SystemResultStatus Load(System& system, Frontend::EmuWindow& emu_window, const std::string& filepath, Service::AM::FrontendAppletParameters& params) {
         InitializeKernel(system);
 
+        if (params.applet_type == Service::AM::AppletType::Application) {
+            current_application_filepath = filepath;
+        }
+
         const auto file = GetGameFileFromPath(virtual_filesystem, filepath);
 
         // Create the application process
@@ -330,7 +334,7 @@ struct System::Impl {
         LaunchTimestampCache::SaveLaunchTimestamp(params.program_id);
 
         // Make the process created be the application
-        kernel.MakeApplicationProcess(process->GetHandle());
+        kernel.SetApplicationProcess(process->GetHandle());
 
         // Set up the rest of the system.
         SystemResultStatus init_result{SetupForApplicationProcess(system, emu_window)};
@@ -467,6 +471,7 @@ struct System::Impl {
     Core::SpeedLimiter speed_limiter;
     ExecuteProgramCallback execute_program_callback;
     ExitCallback exit_callback;
+    ApplicationChangedCallback application_changed_callback;
 
     std::optional<Service::Services> services;
     std::optional<Core::Debugger> debugger;
@@ -488,6 +493,8 @@ struct System::Impl {
     std::array<u64, Core::Hardware::NUM_CPU_CORES> dynarmic_ticks{};
     std::array<u8, 0x20> build_id{};
 
+    std::string current_application_filepath;
+
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
     /// ContentProviderUnion instance
@@ -727,7 +734,25 @@ const Core::SpeedLimiter& System::SpeedLimiter() const {
 }
 
 u64 System::GetApplicationProcessProgramID() const {
-    return impl->kernel.ApplicationProcess()->GetProgramId();
+    const auto* const process = impl->kernel.ApplicationProcess();
+    return process != nullptr ? process->GetProgramId() : 0;
+}
+
+u64 System::GetProgramIdForProcessId(u64 process_id) const {
+    auto process = impl->kernel.GetProcessByProcessId(process_id);
+    return process.IsNull() ? 0 : process->GetProgramId();
+}
+
+u64 System::ResolveCallerProgramId(u64 process_id) const {
+    if (const auto program_id = this->GetProgramIdForProcessId(process_id); program_id != 0) {
+        return program_id;
+    }
+
+    const auto fallback = this->GetApplicationProcessProgramID();
+    LOG_WARNING(Core,
+                "Could not resolve caller process_id={}, falling back to application {:016X}",
+                process_id, fallback);
+    return fallback;
 }
 
 Loader::ResultStatus System::GetGameName(std::string& out) const {
@@ -910,6 +935,10 @@ void System::ExecuteProgram(std::size_t program_index) {
     }
 }
 
+const std::string& System::GetCurrentApplicationFilePath() const {
+    return impl->current_application_filepath;
+}
+
 /// @brief Gets a reference to the user channel stack.
 /// It is used to transfer data between programs.
 std::vector<std::vector<u8>>& System::GetUserChannel() {
@@ -961,6 +990,18 @@ void System::Exit() {
     }
 }
 
+void System::RegisterApplicationChangedCallback(ApplicationChangedCallback&& callback) {
+    impl->application_changed_callback = std::move(callback);
+}
+
+void System::NotifyApplicationChanged(u64 program_id) {
+    //LOG_DEBUG(Core, "Running application changed to {:016X}", program_id);
+
+    if (impl->application_changed_callback) {
+        impl->application_changed_callback(program_id);
+    }
+}
+
 void System::ApplySettings() {
     impl->RefreshTime(*this);
 

src/core/core.h

@@ -322,6 +322,10 @@ public:
 
     [[nodiscard]] u64 GetApplicationProcessProgramID() const;
 
+    [[nodiscard]] u64 GetProgramIdForProcessId(u64 process_id) const;
+
+    [[nodiscard]] u64 ResolveCallerProgramId(u64 process_id) const;
+
     /// Gets the name of the current game
     [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
 
@@ -422,6 +426,7 @@ public:
     void PushGeneralChannelData(std::vector<u8>&& data);
     bool TryPopGeneralChannel(std::vector<u8>& out_data);
     [[nodiscard]] Service::Event& GetGeneralChannelEvent();
+    [[nodiscard]] const std::string& GetCurrentApplicationFilePath() const;
 
     /// Type used for the frontend to designate a callback for System to exit the application.
     using ExitCallback = std::function<void()>;
@@ -435,6 +440,10 @@ public:
     /// Instructs the frontend to exit the application.
     void Exit();
 
+    using ApplicationChangedCallback = std::function<void(u64 program_id)>;
+    void RegisterApplicationChangedCallback(ApplicationChangedCallback&& callback);
+    void NotifyApplicationChanged(u64 program_id);
+
     /// Applies any changes to settings to this core instance.
     void ApplySettings();
 

src/core/file_sys/content_archive.cpp

@@ -29,7 +29,7 @@ static u8 MasterKeyIdForKeyGeneration(u8 key_generation) {
     return std::max<u8>(key_generation, 1) - 1;
 }
 
-NCA::NCA(VirtualFile file_, const NCA* base_nca)
+NCA::NCA(VirtualFile file_, const NCA* base_nca, bool allow_missing_base)
     : file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
     if (file == nullptr) {
         status = Loader::ResultStatus::ErrorNullFile;
@@ -110,7 +110,7 @@ NCA::NCA(VirtualFile file_, const NCA* base_nca)
         }
     }
 
-    if (is_update && base_nca == nullptr) {
+    if (is_update && base_nca == nullptr && !allow_missing_base) {
         status = Loader::ResultStatus::ErrorMissingBKTRBaseRomFS;
     } else {
         status = Loader::ResultStatus::Success;

src/core/file_sys/content_archive.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -63,7 +66,7 @@ inline bool IsDirectoryLogoPartition(const VirtualDir& pfs) {
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
 public:
-    explicit NCA(VirtualFile file, const NCA* base_nca = nullptr);
+    explicit NCA(VirtualFile file, const NCA* base_nca = nullptr, bool allow_missing_base = false);
     ~NCA() override;
 
     Loader::ResultStatus GetStatus() const;

src/core/file_sys/fssystem/fssystem_indirect_storage.cpp

@@ -4,6 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/logging.h"
 #include "core/file_sys/errors.h"
 #include "core/file_sys/fssystem/fssystem_indirect_storage.h"
 
@@ -99,6 +100,18 @@ Result IndirectStorage::GetEntryList(Entry* out_entries, s32* out_entry_count, s
     R_SUCCEED();
 }
 
+void IndirectStorage::ReportMissingOriginal(s64 offset, s64 size) {
+    if (m_reported_missing_original) {
+        return;
+    }
+    m_reported_missing_original = true;
+
+    LOG_ERROR(Common_Filesystem,
+              "Patch storage requests {:#x} bytes at {:#x} from a base storage that is not "
+              "present; this data will read as garbage",
+              size, offset);
+}
+
 size_t IndirectStorage::Read(u8* buffer, size_t size, size_t offset) const {
     // Validate pre-conditions.
     ASSERT(this->IsInitialized());

src/core/file_sys/fssystem/fssystem_indirect_storage.h

@@ -85,6 +85,9 @@ public:
     void SetStorage(s32 idx, VirtualFile storage) {
         ASSERT(0 <= idx && idx < StorageCount);
         m_data_storage[idx] = storage;
+        if (idx == 0) {
+            m_original_missing = storage == nullptr || storage->GetSize() == 0;
+        }
     }
 
     template <typename T>
@@ -130,6 +133,9 @@ protected:
 
     template <bool ContinuousCheck, bool RangeCheck, typename F>
     Result OperatePerEntry(s64 offset, s64 size, F func);
+    // Launching another game makes the original storage inaccessable.
+    // This is a helper for multi-nca games.
+    void ReportMissingOriginal(s64 offset, s64 size);
 
 private:
     struct ContinuousReadingEntry {
@@ -154,6 +160,8 @@ private:
 private:
     mutable BucketTree m_table;
     std::array<VirtualFile, StorageCount> m_data_storage;
+    bool m_original_missing{false};
+    bool m_reported_missing_original{false};
 };
 
 template <bool ContinuousCheck, bool RangeCheck, typename F>
@@ -272,6 +280,10 @@ Result IndirectStorage::OperatePerEntry(s64 offset, s64 size, F func) {
         if (needs_operate) {
             const auto cur_entry_phys_offset = cur_entry.GetPhysicalOffset();
 
+            if (cur_entry.storage_index == 0 && m_original_missing) {
+                this->ReportMissingOriginal(cur_offset, cur_size);
+            }
+
             if constexpr (RangeCheck) {
                 // Get the current data storage's size.
                 s64 cur_data_storage_size = m_data_storage[cur_entry.storage_index]->GetSize();

src/core/file_sys/nca_metadata.h

@@ -48,11 +48,11 @@ struct ContentRecord {
     std::array<u8, 0x10> nca_id;
     std::array<u8, 0x6> size;
     ContentRecordType type;
-    INSERT_PADDING_BYTES(1);
+    u8 id_offset;
 };
 static_assert(sizeof(ContentRecord) == 0x38, "ContentRecord has incorrect size.");
 
-constexpr ContentRecord EMPTY_META_CONTENT_RECORD{{}, {}, {}, ContentRecordType::Meta, {}};
+constexpr ContentRecord EMPTY_META_CONTENT_RECORD{{}, {}, {}, ContentRecordType::Meta, 0};
 
 struct MetaRecord {
     u64_le title_id;

src/core/file_sys/registered_cache.cpp

@@ -567,20 +567,45 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
 }
 
 static std::optional<NcaID> CheckMapForContentRecord(const ankerl::unordered_dense::map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
-    const auto cmnt_iter = map.find(title_id);
+    auto cmnt_iter = map.find(title_id);
+    u8 id_offset = 0;
+
     if (cmnt_iter == map.cend()) {
-        return std::nullopt;
+        const auto program_index = title_id & AOC_TITLE_ID_MASK;
+        if (program_index == 0) {
+            return std::nullopt;
+        }
+
+        cmnt_iter = map.find(title_id & ~AOC_TITLE_ID_MASK);
+        if (cmnt_iter == map.cend()) {
+            return std::nullopt;
+        }
+
+        id_offset = static_cast<u8>(program_index);
     }
 
     const auto& cnmt = cmnt_iter->second;
     const auto& content_records = cnmt.GetContentRecords();
     const auto iter = std::find_if(content_records.cbegin(), content_records.cend(),
-                                   [type](const ContentRecord& rec) { return rec.type == type; });
-    if (iter == content_records.cend()) {
+                                   [type, id_offset](const ContentRecord& rec) {
+                                       return rec.type == type && rec.id_offset == id_offset;
+                                   });
+    if (iter != content_records.cend()) {
+        return std::make_optional(iter->nca_id);
+    }
+
+    if (id_offset != 0) {
         return std::nullopt;
     }
 
-    return std::make_optional(iter->nca_id);
+    const auto fallback_iter =
+        std::find_if(content_records.cbegin(), content_records.cend(),
+                     [type](const ContentRecord& rec) { return rec.type == type; });
+    if (fallback_iter == content_records.cend()) {
+        return std::nullopt;
+    }
+
+    return std::make_optional(fallback_iter->nca_id);
 }
 
 std::optional<NcaID> RegisteredCache::GetNcaIDFromMetadata(u64 title_id,

src/core/file_sys/submission_package.cpp

@@ -12,6 +12,7 @@
 #include "common/hex_util.h"
 #include "common/logging.h"
 #include "core/crypto/key_manager.h"
+#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
@@ -65,10 +66,12 @@ u64 NSP::GetProgramTitleID() const {
     }
 
     auto program_id = expected_program_id;
-    if (program_id == 0) {
-        if (!program_status.empty()) {
-            program_id = program_status.begin()->first;
-        }
+    if (program_id == 0 && !program_status.empty()) {
+        program_id = std::min_element(program_status.cbegin(), program_status.cend(),
+                                      [](const auto& lhs, const auto& rhs) {
+                                          return lhs.first < rhs.first;
+                                      })
+                         ->first;
     }
 
     program_id = program_id + program_index;
@@ -273,8 +276,7 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                     // If the last 3 hexadecimal digits of the NCA's TitleID is between 0x1 and
                     // 0x7FF, this is a multi-program update NCA. Otherwise, this is a regular
                     // update NCA.
-                    if ((next_nca->GetTitleId() & 0x7FF) != 0 &&
-                        (next_nca->GetTitleId() & 0x800) == 0) {
+                    if ((next_nca->GetTitleId() & AOC_TITLE_ID_MASK) != 0) {
                         ncas[next_nca->GetTitleId()][{cnmt.GetType(), rec.type}] =
                             std::move(next_nca);
                     } else {

src/core/hle/kernel/kernel.cpp

@@ -349,9 +349,18 @@ struct KernelCore::Impl {
         object_name_global_data.emplace(kernel);
     }
 
-    void MakeApplicationProcess(KernelCore& kernel, KProcess* process) {
+    void SetApplicationProcess(KernelCore& kernel, KProcess* process) {
+        if (application_process == process)
+            return;
+
+        KProcess* const previous = application_process;
         application_process = process;
-        application_process->Open(kernel);
+
+        if (application_process != nullptr)
+            application_process->Open(kernel);
+
+        if (previous != nullptr)
+            previous->Close(kernel);
     }
 
     /// Sets the host thread ID for the caller.
@@ -879,8 +888,8 @@ void KernelCore::RemoveProcess(KProcess* process) {
     }
 }
 
-void KernelCore::MakeApplicationProcess(KProcess* process) {
-    impl->MakeApplicationProcess(*this, process);
+void KernelCore::SetApplicationProcess(KProcess* process) {
+    impl->SetApplicationProcess(*this, process);
 }
 
 KProcess* KernelCore::ApplicationProcess() {
@@ -891,6 +900,14 @@ const KProcess* KernelCore::ApplicationProcess() const {
     return impl->application_process;
 }
 
+KScopedAutoObject<KProcess> KernelCore::GetProcessByProcessId(u64 process_id) {
+    std::scoped_lock lk{impl->process_list_lock};
+    for (auto* const process : impl->process_list)
+        if (process != nullptr && process->GetProcessId() == process_id)
+            return {*this, process};
+    return {*this, nullptr};
+}
+
 std::list<KScopedAutoObject<KProcess>> KernelCore::GetProcessList() {
     std::list<KScopedAutoObject<KProcess>> processes;
     std::scoped_lock lk{impl->process_list_lock};

src/core/hle/kernel/kernel.h

@@ -124,8 +124,8 @@ public:
     void AppendNewProcess(KProcess* process);
     void RemoveProcess(KProcess* process);
 
-    /// Makes the given process the new application process.
-    void MakeApplicationProcess(KProcess* process);
+    /// Makes the given process the current application process.
+    void SetApplicationProcess(KProcess* process);
 
     /// Retrieves a pointer to the application process.
     KProcess* ApplicationProcess();
@@ -133,6 +133,9 @@ public:
     /// Retrieves a const pointer to the application process.
     const KProcess* ApplicationProcess() const;
 
+    /// Retrieves the process with the given process ID, or a null object.
+    KScopedAutoObject<KProcess> GetProcessByProcessId(u64 process_id);
+
     /// Retrieves the list of processes.
     std::list<KScopedAutoObject<KProcess>> GetProcessList();
 

src/core/hle/service/am/am_results.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -10,6 +13,7 @@ namespace Service::AM {
 constexpr Result ResultNoDataInChannel{ErrorModule::AM, 2};
 constexpr Result ResultNoMessages{ErrorModule::AM, 3};
 constexpr Result ResultLibraryAppletTerminated{ErrorModule::AM, 22};
+constexpr Result ResultApplicationRecordNotFound{ErrorModule::AM, 37};
 constexpr Result ResultInvalidOffset{ErrorModule::AM, 503};
 constexpr Result ResultInvalidStorageType{ErrorModule::AM, 511};
 constexpr Result ResultFatalSectionCountImbalance{ErrorModule::AM, 512};

src/core/hle/service/am/am_types.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 2024 yuzu Emulator Project
@@ -201,6 +201,14 @@ enum class ProgramSpecifyKind : u32 {
     RestartProgram = 2,
 };
 
+// Maufeat: Use enums for zindex instead of using random zindex numbers
+enum AppletZIndex : s32 {
+    Background = 0,
+    Foreground = 1,
+    ForegroundVisible = 2,
+    Overlay = 3,
+};
+
 struct CommonArguments {
     CommonArgumentVersion arguments_version;
     CommonArgumentSize size;

src/core/hle/service/am/applet.cpp

@@ -56,22 +56,22 @@ void Applet::UpdateSuspensionStateLocked(bool force_message) {
     }
 }
 
-void Applet::SetInteractibleLocked(bool interactible) {
-    if (is_interactible == interactible) {
+void Applet::SetInteractibleLocked(bool pad_interactible, bool touch_interactible) {
+    if (is_pad_interactible == pad_interactible && is_touch_interactible == touch_interactible) {
         return;
     }
 
-    is_interactible = interactible;
+    is_pad_interactible = pad_interactible;
+    is_touch_interactible = touch_interactible;
 
     const bool exit_requested = lifecycle_manager.GetExitRequested();
-    const bool input_enabled = interactible && !exit_requested;
+    const bool pad_enabled = pad_interactible && !exit_requested;
+    const bool touch_enabled = touch_interactible && !exit_requested;
 
-    if (applet_id == AppletId::OverlayDisplay || applet_id == AppletId::Application) {
-        LOG_DEBUG(Service_AM, "called, applet={} interactible={} exit_requested={} input_enabled={} overlay_in_foreground={}",
-                 static_cast<u32>(applet_id), interactible, exit_requested, input_enabled, overlay_in_foreground);
-    }
+    LOG_DEBUG(Service_AM, "applet={} pad={} touch={} exit_requested={}",
+              static_cast<u32>(applet_id), pad_enabled, touch_enabled, exit_requested);
 
-    hid_registration.EnableAppletToGetInput(input_enabled);
+    hid_registration.EnableAppletToGetInput(pad_enabled, touch_enabled);
 }
 
 void Applet::OnProcessTerminatedLocked() {

src/core/hle/service/am/applet.h

@@ -125,9 +125,11 @@ struct Applet {
     bool album_image_taken_notification_enabled{};
     bool record_volume_muted{};
     bool is_activity_runnable{};
-    bool is_interactible{true};
+    bool is_pad_interactible{true};
+    bool is_touch_interactible{true};
     bool window_visible{true};
-    bool overlay_in_foreground{false};
+    bool overlay_watching_short_home_button{false};
+    bool overlay_handling_touch_input{false};
 
     // Events
     Event overlay_event;
@@ -148,7 +150,7 @@ struct Applet {
 
     // Process state management
     void UpdateSuspensionStateLocked(bool force_message);
-    void SetInteractibleLocked(bool interactible);
+    void SetInteractibleLocked(bool pad_interactible, bool touch_interactible);
     void OnProcessTerminatedLocked();
 };
 

src/core/hle/service/am/display_layer_manager.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 2024 yuzu Emulator Project
@@ -6,6 +6,7 @@
 
 #include "core/core.h"
 #include "core/hle/service/am/display_layer_manager.h"
+#include "core/hle/service/nvnflinger/hwc_layer.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/vi/application_display_service.h"
 #include "core/hle/service/vi/container.h"
@@ -33,6 +34,7 @@ void DisplayLayerManager::Initialize(Core::System& system, Kernel::KProcess* pro
     m_system_shared_buffer_id = 0;
     m_system_shared_layer_id = 0;
     m_applet_id = applet_id;
+    m_library_applet_mode = mode;
     m_buffer_sharing_enabled = false;
     m_blending_enabled = mode == LibraryAppletMode::PartialForeground ||
                          mode == LibraryAppletMode::PartialForegroundIndirectDisplay;
@@ -72,14 +74,16 @@ Result DisplayLayerManager::CreateManagedDisplayLayer(u64* out_layer_id) {
         out_layer_id, 0, display_id, Service::AppletResourceUserId{m_process->GetProcessId()}));
 
     m_manager_display_service->SetLayerVisibility(m_visible, *out_layer_id);
+    (void)m_display_service->GetContainer()->SetLayerStackMask(*out_layer_id,
+                                                              this->GetLayerStackMask());
 
     if (m_applet_id != AppletId::Application) {
         (void)m_manager_display_service->SetLayerBlending(m_blending_enabled, *out_layer_id);
         if (m_applet_id == AppletId::OverlayDisplay) {
-            (void)m_manager_display_service->SetLayerZIndex(-1, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(Overlay, *out_layer_id);
             (void)m_display_service->GetContainer()->SetLayerIsOverlay(*out_layer_id, true);
         } else {
-            (void)m_manager_display_service->SetLayerZIndex(1, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(Foreground, *out_layer_id);
         }
     }
 
@@ -122,10 +126,12 @@ Result DisplayLayerManager::IsSystemBufferSharingEnabled() {
 
     // Ensure the overlay layer is visible
     m_manager_display_service->SetLayerVisibility(m_visible, m_system_shared_layer_id);
+    (void)m_display_service->GetContainer()->SetLayerStackMask(m_system_shared_layer_id,
+                                                              this->GetLayerStackMask());
     m_manager_display_service->SetLayerBlending(m_blending_enabled, m_system_shared_layer_id);
-    s32 initial_z = 1;
+    s32 initial_z = Foreground;
     if (m_applet_id == AppletId::OverlayDisplay) {
-        initial_z = -1;
+        initial_z = Overlay;
         (void)m_display_service->GetContainer()->SetLayerIsOverlay(m_system_shared_layer_id, true);
     }
     m_manager_display_service->SetLayerZIndex(initial_z, m_system_shared_layer_id);
@@ -142,6 +148,36 @@ Result DisplayLayerManager::GetSystemSharedLayerHandle(u64* out_system_shared_bu
     R_SUCCEED();
 }
 
+u32 DisplayLayerManager::GetLayerStackMask() const {
+    using Nvnflinger::LayerStackBit;
+    using Nvnflinger::LayerStackId;
+
+    constexpr u32 Displayed = LayerStackBit(LayerStackId::Default);
+    constexpr u32 Screenshot = LayerStackBit(LayerStackId::Screenshot);
+    constexpr u32 Recording = LayerStackBit(LayerStackId::Recording);
+    constexpr u32 LastFrame = LayerStackBit(LayerStackId::LastFrame);
+    constexpr u32 Debug = LayerStackBit(LayerStackId::ApplicationForDebug);
+
+    switch (m_applet_id) {
+        case AppletId::Application:
+            return Displayed | Screenshot | Recording | LastFrame | Debug;
+        case AppletId::OverlayDisplay:
+            return Displayed;
+        case AppletId::QLaunch:
+            return Displayed;
+        default:
+            break;
+    }
+
+    switch (m_library_applet_mode) {
+    case LibraryAppletMode::AllForeground:
+    case LibraryAppletMode::AllForegroundInitiallyHidden:
+        return Displayed | Screenshot | LastFrame;
+    default:
+        return Displayed | Screenshot;
+    }
+}
+
 void DisplayLayerManager::SetWindowVisibility(bool visible) {
     if (m_visible == visible) {
         return;
@@ -185,10 +221,17 @@ void DisplayLayerManager::SetOverlayZIndex(s32 z_index) {
 }
 
 Result DisplayLayerManager::WriteAppletCaptureBuffer(bool* out_was_written,
-                                                     s32* out_fbshare_layer_index) {
+                                                     s32* out_fbshare_layer_index,
+                                                     VI::CaptureKind kind) {
     R_UNLESS(m_buffer_sharing_enabled, VI::ResultPermissionDenied);
     R_RETURN(m_display_service->GetContainer()->GetSharedBufferManager()->WriteAppletCaptureBuffer(
-        out_was_written, out_fbshare_layer_index));
+        out_was_written, out_fbshare_layer_index, kind));
+}
+
+Result DisplayLayerManager::ClearAppletCaptureBuffer(s32 fbshare_layer_index, u32 color) {
+    R_UNLESS(m_buffer_sharing_enabled, VI::ResultPermissionDenied);
+    R_RETURN(m_display_service->GetContainer()->GetSharedBufferManager()->ClearAppletCaptureBuffer(
+        fbshare_layer_index, color));
 }
 
 } // namespace Service::AM