[vk_texture_cache] drop depth comparison sampler fallback

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/Game.kt

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2023 yuzu Emulator Project
@@ -37,7 +37,7 @@ class Game(
 
     val settingsName: String
         get() {
-            val programIdLong = programId.toLongOrNull() ?: 0L
+            val programIdLong = programId.toLong()
             return if (programIdLong == 0L) {
                 FileUtil.getFilename(Uri.parse(path))
             } else {
@@ -47,7 +47,7 @@ class Game(
 
     val programIdHex: String
         get() {
-            val programIdLong = programId.toLongOrNull() ?: 0L
+            val programIdLong = programId.toLong()
             return if (programIdLong == 0L) {
                 "0"
             } else {

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

@@ -73,20 +73,16 @@ Result DisplayLayerManager::CreateManagedDisplayLayer(u64* out_layer_id) {
     R_TRY(m_manager_display_service->CreateManagedLayer(
         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(Overlay, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(-1, *out_layer_id);
+            (void)m_display_service->GetContainer()->SetLayerIsOverlay(*out_layer_id, true);
         } else {
-            (void)m_manager_display_service->SetLayerZIndex(Foreground, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(1, *out_layer_id);
         }
     }
-
-    m_display_service->GetContainer()->SetLayerZIndex(*out_layer_id, true);
+    (void)m_display_service->GetContainer()->SetLayerZIndex(*out_layer_id, true);
     m_managed_display_layers.emplace(*out_layer_id);
 
     R_SUCCEED();
@@ -126,16 +122,14 @@ Result DisplayLayerManager::IsSystemBufferSharingEnabled() {
 
     // Ensure the overlay layer is visible
     m_manager_display_service->SetLayerVisibility(m_visible, m_system_shared_layer_id);
-    (void)m_manager_display_service->SetLayerBlending(m_blending_enabled, m_system_shared_layer_id);
-    s32 initial_z = Foreground;
+    m_manager_display_service->SetLayerBlending(m_blending_enabled, m_system_shared_layer_id);
+    s32 initial_z = 1;
+    (void)m_display_service->GetContainer()->SetLayerZIndex(m_system_shared_layer_id, true);
     if (m_applet_id == AppletId::OverlayDisplay) {
-        initial_z = Overlay;
-        (void)m_manager_display_service->SetLayerZIndex(initial_z, m_system_shared_layer_id);
+        initial_z = -1;
         (void)m_display_service->GetContainer()->SetLayerIsOverlay(m_system_shared_layer_id, true);
     }
     m_manager_display_service->SetLayerZIndex(initial_z, m_system_shared_layer_id);
-    m_display_service->GetContainer()->SetLayerZIndex(m_system_shared_layer_id, true);
-    m_managed_display_layers.emplace(m_system_shared_layer_id);
     R_SUCCEED();
 }
 

src/core/hle/service/ns/read_only_application_control_data_interface.cpp

@@ -142,7 +142,6 @@ IReadOnlyApplicationControlDataInterface::IReadOnlyApplicationControlDataInterfa
         {10, &IReadOnlyApplicationControlDataInterface::ListApplicationIcon, "ListApplicationIcon"},
         {13, &IReadOnlyApplicationControlDataInterface::ListApplicationTitle, "ListApplicationTitle"},
         {19, D<&IReadOnlyApplicationControlDataInterface::GetApplicationControlData3>, "GetApplicationControlData"},
-        {23, D<&IReadOnlyApplicationControlDataInterface::GetApplicationControlData3>, "GetApplicationControlData"},
     };
     // clang-format on
 

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_memory.cpp

@@ -274,8 +274,8 @@ std::pair<oaknut::XReg, oaknut::XReg> InlinePageTableEmitVAddrLookup(oaknut::Cod
     code.LDR(Xscratch0, Xpagetable, Xscratch0);
 
     if (ctx.conf.page_table_marked_bit) {
-        code.TST(Xscratch0, 1ULL << *ctx.conf.page_table_marked_bit);
-        code.B(NE, *fallback);
+        // check for marked bit
+        code.TBNZ(Xscratch0, *ctx.conf.page_table_marked_bit, *fallback);
     }
 
     if (ctx.conf.page_table_pointer_mask != 0) {

src/input_common/drivers/mouse.cpp

@@ -4,16 +4,17 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <chrono>
+#include <thread>
 #include <fmt/ranges.h>
 #include <math.h>
 
 #include "common/param_package.h"
 #include "common/settings.h"
-#include "common/steady_clock.h"
+#include "common/thread.h"
 #include "input_common/drivers/mouse.h"
 
 namespace InputCommon {
+constexpr int update_time = 10;
 constexpr float default_panning_sensitivity = 0.0010f;
 constexpr float default_stick_sensitivity = 0.0006f;
 constexpr float default_deadzone_counterweight = 0.01f;
@@ -73,31 +74,33 @@ Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(input_engine_))
     last_motion_change = {};
 }
 
-void Mouse::UpdateStickInput(Common::SteadyClock::time_point timestamp) {
-    if (IsMousePanningEnabled()) {
-        const float length = last_mouse_change.Length();
-
-        // Prevent input from exceeding the max range (1.0f) too much,
-        // but allow some room to make it easier to sustain
-        if (length > maximum_stick_range) {
-            last_mouse_change /= length;
-            last_mouse_change *= maximum_stick_range;
-        }
-
-        SetAxis(identifier, mouse_axis_x, last_mouse_change[0]);
-        SetAxis(identifier, mouse_axis_y, -last_mouse_change[1]);
-
-        // Decay input over time
-        const float clamped_length = (std::min)(1.0f, length);
-        const float decay_strength = Settings::values.mouse_panning_decay_strength.GetValue();
-        const float decay = 1 - clamped_length * clamped_length * decay_strength * 0.01f;
-        const float min_decay = Settings::values.mouse_panning_min_decay.GetValue();
-        const float clamped_decay = (std::min)(1 - min_decay / 100.0f, decay);
-        last_mouse_change *= clamped_decay;
+void Mouse::UpdateStickInput() {
+    if (!IsMousePanningEnabled()) {
+        return;
     }
+
+    const float length = last_mouse_change.Length();
+
+    // Prevent input from exceeding the max range (1.0f) too much,
+    // but allow some room to make it easier to sustain
+    if (length > maximum_stick_range) {
+        last_mouse_change /= length;
+        last_mouse_change *= maximum_stick_range;
+    }
+
+    SetAxis(identifier, mouse_axis_x, last_mouse_change[0]);
+    SetAxis(identifier, mouse_axis_y, -last_mouse_change[1]);
+
+    // Decay input over time
+    const float clamped_length = (std::min)(1.0f, length);
+    const float decay_strength = Settings::values.mouse_panning_decay_strength.GetValue();
+    const float decay = 1 - clamped_length * clamped_length * decay_strength * 0.01f;
+    const float min_decay = Settings::values.mouse_panning_min_decay.GetValue();
+    const float clamped_decay = (std::min)(1 - min_decay / 100.0f, decay);
+    last_mouse_change *= clamped_decay;
 }
 
-void Mouse::UpdateMotionInput(Common::SteadyClock::time_point timestamp) {
+void Mouse::UpdateMotionInput() {
     const float sensitivity =
         IsMousePanningEnabled() ? default_motion_panning_sensitivity : default_motion_sensitivity;
 
@@ -111,21 +114,23 @@ void Mouse::UpdateMotionInput(Common::SteadyClock::time_point timestamp) {
         last_motion_change[1] = last_motion_change[1] * multiplier;
     }
 
-    if (IsMousePanningEnabled()) {
-        last_motion_change[0] = 0;
-        last_motion_change[1] = 0;
-    }
-    last_motion_change[2] = 0;
-
-    SetMotion(motion_identifier, 0, BasicMotion{
+    const BasicMotion motion_data{
         .gyro_x = last_motion_change[0] * sensitivity,
         .gyro_y = last_motion_change[1] * sensitivity,
         .gyro_z = last_motion_change[2] * sensitivity,
         .accel_x = 0,
         .accel_y = 0,
         .accel_z = 0,
-        .delta_timestamp = u64(std::chrono::duration_cast<std::chrono::microseconds>(timestamp - last_notify_timestamp).count()),
-    });
+        .delta_timestamp = update_time * 1000,
+    };
+
+    if (IsMousePanningEnabled()) {
+        last_motion_change[0] = 0;
+        last_motion_change[1] = 0;
+    }
+    last_motion_change[2] = 0;
+
+    SetMotion(motion_identifier, 0, motion_data);
 }
 
 void Mouse::Move(int x, int y, int center_x, int center_y) {
@@ -144,27 +149,29 @@ void Mouse::Move(int x, int y, int center_x, int center_y) {
             last_mouse_change /= length;
             last_mouse_change *= deadzone_cw;
         }
-    } else {
-        if (button_pressed) {
-            const auto mouse_move = Common::Vec<int, 2>(x, y) - mouse_origin;
-            const float x_sensitivity = Settings::values.mouse_panning_x_sensitivity.GetValue() * default_stick_sensitivity;
-            const float y_sensitivity = Settings::values.mouse_panning_y_sensitivity.GetValue() * default_stick_sensitivity;
-            SetAxis(identifier, mouse_axis_x, float(mouse_move[0]) * x_sensitivity);
-            SetAxis(identifier, mouse_axis_y, float(-mouse_move[1]) * y_sensitivity);
-            last_motion_change = {
-                float(-mouse_move[1]) * x_sensitivity,
-                float(-mouse_move[0]) * y_sensitivity,
-                last_motion_change[2],
-            };
-        }
+        return;
+    }
+
+    if (button_pressed) {
+        const auto mouse_move = Common::Vec<int, 2>(x, y) - mouse_origin;
+        const float x_sensitivity =
+            Settings::values.mouse_panning_x_sensitivity.GetValue() * default_stick_sensitivity;
+        const float y_sensitivity =
+            Settings::values.mouse_panning_y_sensitivity.GetValue() * default_stick_sensitivity;
+        SetAxis(identifier, mouse_axis_x, float(mouse_move[0]) * x_sensitivity);
+        SetAxis(identifier, mouse_axis_y, float(-mouse_move[1]) * y_sensitivity);
+
+        last_motion_change = {
+            float(-mouse_move[1]) * x_sensitivity,
+            float(-mouse_move[0]) * y_sensitivity,
+            last_motion_change[2],
+        };
     }
 }
 
 void Mouse::NotifyChanged() {
-    auto const timestamp = Common::SteadyClock::Now();
-    UpdateStickInput(timestamp);
-    UpdateMotionInput(timestamp);
-    last_notify_timestamp = timestamp;
+    UpdateStickInput();
+    UpdateMotionInput();
 }
 
 void Mouse::MouseMove(f32 touch_x, f32 touch_y) {
@@ -216,8 +223,8 @@ void Mouse::MouseWheelChange(int x, int y) {
     wheel_position[0] += x;
     wheel_position[1] += y;
     last_motion_change[2] += static_cast<f32>(y);
-    SetAxis(identifier, wheel_axis_x, f32(wheel_position[0]));
-    SetAxis(identifier, wheel_axis_y, f32(wheel_position[1]));
+    SetAxis(identifier, wheel_axis_x, static_cast<f32>(wheel_position[0]));
+    SetAxis(identifier, wheel_axis_y, static_cast<f32>(wheel_position[1]));
 }
 
 void Mouse::ReleaseAllButtons() {

src/input_common/drivers/mouse.h

@@ -7,9 +7,7 @@
 #pragma once
 
 #include <thread>
-#include <chrono>
 
-#include "common/steady_clock.h"
 #include "common/polyfill_thread.h"
 #include "common/vector_math.h"
 #include "input_common/input_engine.h"
@@ -103,8 +101,8 @@ public:
     Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;
 
 private:
-    void UpdateStickInput(Common::SteadyClock::time_point timestamp);
-    void UpdateMotionInput(Common::SteadyClock::time_point timestamp);
+    void UpdateStickInput();
+    void UpdateMotionInput();
     bool IsMousePanningEnabled();
 
     Common::Input::ButtonNames GetUIButtonName(const Common::ParamPackage& params) const;
@@ -114,7 +112,6 @@ private:
     Common::Vec<float, 2> last_mouse_change;
     Common::Vec<float, 3> last_motion_change;
     Common::Vec<int, 2> wheel_position;
-    Common::SteadyClock::time_point last_notify_timestamp{};
     bool button_pressed = false;
 };
 

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -2850,8 +2850,6 @@ Sampler::VariantKey Sampler::MakeKey(const ImageView& image_view, bool is_depth)
     VariantKey key{};
     key.reduce_anisotropy = has_added_anisotropy && !image_view.SupportsAnisotropy();
     key.force_nearest = has_linear_filtering && IsPixelFormatInteger(image_view.format);
-    key.drop_depth_comparison =
-        is_depth && has_depth_comparison && !image_view.SupportsDepthComparison();
     key.drop_reduction = has_minmax_reduction && !image_view.SupportsMinmaxFilter();
     key.drop_custom_border = has_custom_border_colors && image_view.RequiresBorderColorFormat();
     key.srgb_border = has_srgb_border_color && IsPixelFormatSRGB(image_view.format);
@@ -2929,9 +2927,6 @@ VkSampler Sampler::Emplace(VariantKey key) {
         create_info.anisotropyEnable = static_cast<VkBool32>(default_anisotropy > 1.0f);
         create_info.maxAnisotropy = default_anisotropy;
     }
-    if (key.drop_depth_comparison) {
-        create_info.compareEnable = VK_FALSE;
-    }
     if (!custom_border) {
         create_info.borderColor = ConvertBorderColor(color);
     }

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -536,7 +536,6 @@ private:
     struct VariantKey {
         bool reduce_anisotropy;
         bool force_nearest;
-        bool drop_depth_comparison;
         bool drop_reduction;
         bool drop_custom_border;
         bool srgb_border;

src/yuzu/bootmanager.cpp

@@ -73,7 +73,6 @@ class QPaintEngine;
 class QSurface;
 
 constexpr int default_mouse_constrain_timeout = 10;
-constexpr int default_mouse_update_timeout = 5;
 
 class RenderWidget : public QWidget {
 public:
@@ -139,10 +138,6 @@ GRenderWindow::GRenderWindow(MainWindow* parent,
 
     mouse_constrain_timer.setInterval(default_mouse_constrain_timeout);
     connect(&mouse_constrain_timer, &QTimer::timeout, this, &GRenderWindow::ConstrainMouse);
-
-    mouse_update_timer.setInterval(default_mouse_update_timeout);
-    connect(&mouse_update_timer, &QTimer::timeout, this, &GRenderWindow::UpdateMouse);
-    mouse_update_timer.start();
 }
 
 void GRenderWindow::ExecuteProgram(std::size_t program_index) {
@@ -492,6 +487,7 @@ void GRenderWindow::mousePressEvent(QMouseEvent* event) {
     input_subsystem->GetMouse()->PressMouseButton(button);
     input_subsystem->GetMouse()->PressButton(pos.x(), pos.y(), button);
     input_subsystem->GetMouse()->PressTouchButton(touch_x, touch_y, button);
+    input_subsystem->GetMouse()->NotifyChanged();
 
     emit MouseActivity();
 }
@@ -512,6 +508,7 @@ void GRenderWindow::mouseMoveEvent(QMouseEvent* event) {
     input_subsystem->GetMouse()->MouseMove(touch_x, touch_y);
     input_subsystem->GetMouse()->TouchMove(touch_x, touch_y);
     input_subsystem->GetMouse()->Move(pos.x(), pos.y(), center_x, center_y);
+    input_subsystem->GetMouse()->NotifyChanged();
 
     // Center mouse for mouse panning
     if (Settings::values.mouse_panning && !Settings::values.mouse_enabled) {
@@ -521,7 +518,8 @@ void GRenderWindow::mouseMoveEvent(QMouseEvent* event) {
     // Constrain mouse for mouse emulation with mouse panning
     if (Settings::values.mouse_panning && Settings::values.mouse_enabled) {
         const auto [clamped_mouse_x, clamped_mouse_y] = ClipToTouchScreen(x, y);
-        QCursor::setPos(mapToGlobal(QPoint{int(clamped_mouse_x), int(clamped_mouse_y)}));
+        QCursor::setPos(mapToGlobal(
+            QPoint{static_cast<int>(clamped_mouse_x), static_cast<int>(clamped_mouse_y)}));
     }
 
     mouse_constrain_timer.stop();
@@ -536,10 +534,16 @@ void GRenderWindow::mouseReleaseEvent(QMouseEvent* event) {
 
     const auto button = QtButtonToMouseButton(event->button());
     input_subsystem->GetMouse()->ReleaseButton(button);
+    input_subsystem->GetMouse()->NotifyChanged();
 }
 
 void GRenderWindow::ConstrainMouse() {
-    if (QtCommon::emu_thread == nullptr || Settings::values.mouse_panning || !this->isActiveWindow()) {
+    if (QtCommon::emu_thread == nullptr || !Settings::values.mouse_panning) {
+        mouse_constrain_timer.stop();
+        return;
+    }
+
+    if (!this->isActiveWindow()) {
         mouse_constrain_timer.stop();
         return;
     }
@@ -548,22 +552,22 @@ void GRenderWindow::ConstrainMouse() {
         const auto pos = mapFromGlobal(QCursor::pos());
         const int new_pos_x = std::clamp(pos.x(), 0, width());
         const int new_pos_y = std::clamp(pos.y(), 0, height());
-        QCursor::setPos(mapToGlobal(QPoint{new_pos_x, new_pos_y}));
-    } else {
-        const int center_x = width() / 2;
-        const int center_y = height() / 2;
-        QCursor::setPos(mapToGlobal(QPoint{center_x, center_y}));
-    }
-}
 
-void GRenderWindow::UpdateMouse() {
-    input_subsystem->GetMouse()->NotifyChanged(); // required to reset mouse once it's no longer moved
+        QCursor::setPos(mapToGlobal(QPoint{new_pos_x, new_pos_y}));
+        return;
+    }
+
+    const int center_x = width() / 2;
+    const int center_y = height() / 2;
+
+    QCursor::setPos(mapToGlobal(QPoint{center_x, center_y}));
 }
 
 void GRenderWindow::wheelEvent(QWheelEvent* event) {
     const int x = event->angleDelta().x();
     const int y = event->angleDelta().y();
     input_subsystem->GetMouse()->MouseWheelChange(x, y);
+    input_subsystem->GetMouse()->NotifyChanged();
 }
 
 void GRenderWindow::TouchBeginEvent(const QTouchEvent* event) {
@@ -712,6 +716,7 @@ void GRenderWindow::focusOutEvent(QFocusEvent* event) {
     input_subsystem->GetKeyboard()->ReleaseAllKeys();
     input_subsystem->GetTouchScreen()->ReleaseAllTouch();
     input_subsystem->GetMouse()->ReleaseAllButtons();
+    input_subsystem->GetMouse()->NotifyChanged();
 }
 
 void GRenderWindow::resizeEvent(QResizeEvent* event) {

src/yuzu/bootmanager.h

@@ -144,7 +144,6 @@ private:
     void TouchUpdateEvent(const QTouchEvent* event);
     void TouchEndEvent();
     void ConstrainMouse();
-    void UpdateMouse();
 
     void RequestCameraCapture();
     void OnCameraCapture(int requestId, const QImage& img);
@@ -185,7 +184,6 @@ private:
 #endif
 
     QTimer mouse_constrain_timer;
-    QTimer mouse_update_timer;
 
 protected:
     void showEvent(QShowEvent* event) override;

src/yuzu_cmd/emu_window/emu_window_sdl3.cpp

@@ -37,16 +37,10 @@ EmuWindow_SDL3::EmuWindow_SDL3(InputCommon::InputSubsystem* input_subsystem_, Co
         SDL_SetWindowTitle(this_->render_window, title.c_str());
         return 2000;
     }, this);
-    mouse_timer = SDL_AddTimer(100, [](void *userdata, SDL_TimerID, Uint32) -> Uint32 {
-        auto* this_ = (EmuWindow_SDL3*)userdata;
-        this_->input_subsystem->GetMouse()->NotifyChanged();
-        return 100;
-    }, this);
 }
 
 EmuWindow_SDL3::~EmuWindow_SDL3() {
     SDL_RemoveTimer(titlebar_timer);
-    SDL_RemoveTimer(mouse_timer);
     system.HIDCore().UnloadInputDevices();
     input_subsystem->Shutdown();
     SDL_Quit();

src/yuzu_cmd/emu_window/emu_window_sdl3.h

@@ -84,9 +84,6 @@ protected:
     /// Periodic changer of titlebar (independent of event loop)
     SDL_TimerID titlebar_timer;
 
-    // Mouse resetter once it
-    SDL_TimerID mouse_timer;
-
     /// Is the window still open?
     bool is_open = true;