[*] monster hunter rise evidences for flicker/slowdown paths

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

-------------------
Another batch of improvements and fixes for Carousel.

- Added display wise scaling factor for compatibility with 16:9 and 4:3 devices;
- Fixed snap to center feature being lost sometimes;
- Reworked entire bottom inset mechanism (made it event driven, and added use of getInsetsIgnoringVisibility) to avoid weird resizing on Recents (alt+tab) transitions.

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

src/android/app/src/main/java/org/yuzu/yuzu_emu/ui/GamesFragment.kt

@@ -47,7 +47,6 @@ import info.debatty.java.stringsimilarity.Jaccard
 import info.debatty.java.stringsimilarity.JaroWinkler
 import java.util.Locale
 import androidx.core.content.edit
-import androidx.core.view.doOnNextLayout
 
 class GamesFragment : Fragment() {
     private var _binding: FragmentGamesBinding? = null
@@ -59,7 +58,6 @@ class GamesFragment : Fragment() {
     private var originalHeaderLeftMargin: Int? = null
 
     private var lastViewType: Int = GameAdapter.VIEW_TYPE_GRID
-    private var fallbackBottomInset: Int = 0
     private var pendingPostReloadListSettle = false
     private var pendingPostReloadListSettleGeneration = 0
     private var gameListSubmitGeneration = 0
@@ -227,12 +225,7 @@ class GamesFragment : Fragment() {
                 }
                 else -> throw IllegalArgumentException("Invalid view type: $savedViewType")
             }
-            if (savedViewType == GameAdapter.VIEW_TYPE_CAROUSEL) {
-                (binding.gridGames as? View)?.let { it -> ViewCompat.requestApplyInsets(it)}
-                doOnNextLayout { //Carousel: important to avoid overlap issues
-                    (this as? CarouselRecyclerView)?.notifyLaidOut(fallbackBottomInset)
-                }
-            } else {
+            if (savedViewType != GameAdapter.VIEW_TYPE_CAROUSEL) {
                 (this as? CarouselRecyclerView)?.setupCarousel(false)
             }
             adapter = gameAdapter
@@ -590,11 +583,6 @@ class GamesFragment : Fragment() {
                 qlaunchButton.layoutParams = mlpQLaunch
             }
 
-            val navInsets = windowInsets.getInsets(WindowInsetsCompat.Type.navigationBars())
-            val gestureInsets = windowInsets.getInsets(WindowInsetsCompat.Type.systemGestures())
-            val bottomInset = maxOf(navInsets.bottom, gestureInsets.bottom, cutoutInsets.bottom)
-            fallbackBottomInset = bottomInset
-            (binding.gridGames as? CarouselRecyclerView)?.notifyInsetsReady(bottomInset)
             windowInsets
         }
 }

src/android/app/src/main/java/org/yuzu/yuzu_emu/views/CarouselRecyclerView.kt

@@ -12,13 +12,16 @@ import androidx.recyclerview.widget.PagerSnapHelper
 import androidx.recyclerview.widget.RecyclerView
 import kotlin.math.abs
 import kotlin.math.cos
+import kotlin.math.pow
 import kotlin.math.sin
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.adapters.GameAdapter
 import androidx.core.view.doOnNextLayout
+import androidx.core.view.ViewCompat
 import org.yuzu.yuzu_emu.YuzuApplication
 import androidx.preference.PreferenceManager
 import androidx.core.view.WindowInsetsCompat
+import org.yuzu.yuzu_emu.utils.FullscreenHelper
 /**
  * CarouselRecyclerView encapsulates all carousel content for the games UI.
  * It manages overlapping cards, center snapping, custom drawing order,
@@ -32,7 +35,9 @@ class CarouselRecyclerView @JvmOverloads constructor(
 
     private var overlapFactor: Float = 0f
     private var overlapPx: Int = 0
-    private var bottomInset: Int = -1
+    private var bottomInset: Int = 0
+    private var latestWindowInsets: WindowInsetsCompat? = null
+    private var cardGeometryInitialized: Boolean = false
     private var overlapDecoration: OverlappingDecoration? = null
     private var pagerSnapHelper: PagerSnapHelper? = null
     private var scalingScrollListener: OnScrollListener? = null
@@ -91,6 +96,38 @@ class CarouselRecyclerView @JvmOverloads constructor(
 
     init {
         setChildrenDrawingOrderEnabled(true)
+        ViewCompat.setOnApplyWindowInsetsListener(this) { _, insets ->
+            latestWindowInsets = insets
+            updateCardGeometry()
+            applyCarouselPadding()
+            insets
+        }
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        ViewCompat.requestApplyInsets(this)
+    }
+
+    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+        super.onSizeChanged(w, h, oldw, oldh)
+        if (w != oldw || h != oldh) {
+            updateCardGeometry()
+            applyCarouselPadding()
+        }
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        super.onLayout(changed, left, top, right, bottom)
+        if (isCarouselMode) updateChildScalesAndAlpha()
+    }
+
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        super.onWindowFocusChanged(hasFocus)
+        if (hasFocus) {
+            ViewCompat.requestApplyInsets(this)
+            post { updateCardGeometry() }
+        }
     }
 
     override fun setAdapter(adapter: Adapter<*>?) {
@@ -103,6 +140,8 @@ class CarouselRecyclerView @JvmOverloads constructor(
         super.setAdapter(adapter)
 
         (adapter as? GameAdapter)?.registerAdapterDataObserver(carouselAdapterObserver)
+        updateCardGeometry()
+        applyCarouselPadding()
     }
 
     private fun calculateCenter(width: Int, paddingStart: Int, paddingEnd: Int): Int {
@@ -253,40 +292,71 @@ class CarouselRecyclerView @JvmOverloads constructor(
         }
     }
 
-    fun notifyInsetsReady(newBottomInset: Int) {
-        if (bottomInset != newBottomInset) {
-            bottomInset = newBottomInset
-        }
-
-        if (isCarouselMode) {
-            setupCarousel(true)
+    private fun resolveBottomInset(windowInsets: WindowInsetsCompat): Int {
+        val navigationBottom = if (FullscreenHelper.isFullscreenEnabled(context)) {
+            0
         } else {
-            setupCarousel(false)
+            windowInsets.getInsetsIgnoringVisibility(WindowInsetsCompat.Type.navigationBars()).bottom
         }
+        val gestureInsets = windowInsets.getInsetsIgnoringVisibility(
+            WindowInsetsCompat.Type.systemGestures()
+        )
+        val cutoutInsets = windowInsets.getInsetsIgnoringVisibility(
+            WindowInsetsCompat.Type.displayCutout()
+        )
+        return maxOf(navigationBottom, gestureInsets.bottom, cutoutInsets.bottom)
     }
 
-    fun notifyLaidOut(fallBackBottomInset: Int) {
-        if (bottomInset < 0) bottomInset = fallBackBottomInset
-        var gameAdapter = adapter as? GameAdapter ?: return
-        var newCardSize = cardSize(bottomInset)
-        if (gameAdapter.cardSize != newCardSize) {
-            gameAdapter.setCardSize(newCardSize)
-        }
+    private fun updateCardGeometry() {
+        if (!isCarouselMode || height <= 0) return
 
-        if (isCarouselMode) {
-            setupCarousel(true)
-        }
-    }
+        val gameAdapter = adapter as? GameAdapter ?: return
+        val windowInsets = latestWindowInsets ?: ViewCompat.getRootWindowInsets(this) ?: return
 
-    fun cardSize(bottomInset: Int): Int {
+        if (cardGeometryInitialized && !hasWindowFocus()) return
+
+        val newBottomInset = resolveBottomInset(windowInsets).coerceIn(0, height)
         val internalFactor = resources.getFraction(R.fraction.carousel_card_size_factor, 1, 1)
         val userFactor = preferences.getFloat(CAROUSEL_CARD_SIZE_FACTOR, internalFactor).coerceIn(
             0f,
             1f
         )
-        val scaledHeight = height * userFactor
-        val availableHeight = height - bottomInset
-        return minOf(scaledHeight.toInt(), availableHeight.toInt())
+        val screenWidth = resources.displayMetrics.widthPixels.toFloat()
+        val screenHeight = resources.displayMetrics.heightPixels.toFloat()
+        val aspectFactor = ((screenWidth / screenHeight) / (20f / 9f))
+            .pow(0.75f)
+            .coerceIn(0.5f, 1f)
+        val newCardSize = minOf(
+            (height * userFactor).toInt(),
+            height - newBottomInset,
+            (height * aspectFactor).toInt()
+        )
+        if (newCardSize <= 0) return
+        val insetChanged = bottomInset != newBottomInset
+        val cardSizeChanged = gameAdapter.cardSize != newCardSize
+
+        bottomInset = newBottomInset
+        cardGeometryInitialized = true
+
+        if (cardSizeChanged) gameAdapter.setCardSize(newCardSize)
+        if (insetChanged || cardSizeChanged) setupCarousel(true)
+    }
+
+    private fun applyCarouselPadding() {
+        if (!isCarouselMode) return
+
+        val gameAdapter = adapter as? GameAdapter ?: return
+        val cardSize = gameAdapter.cardSize
+        if (cardSize <= 0 || bottomInset < 0) return
+
+        val topPadding = ((height - bottomInset - cardSize) / 2).coerceAtLeast(0)
+        val sidePadding = (width - cardSize) / 2
+        if (paddingLeft != sidePadding || paddingTop != topPadding ||
+            paddingRight != sidePadding || paddingBottom != 0
+        ) {
+            setPadding(sidePadding, topPadding, sidePadding, 0)
+        }
+        clipToPadding = false
     }
 
     fun setupCarousel(enabled: Boolean) {
@@ -315,9 +385,6 @@ class CarouselRecyclerView @JvmOverloads constructor(
                 internalFlingMultiplier
             ).coerceIn(1f, 5f)
 
-            // Detach SnapHelper during setup
-            pagerSnapHelper?.attachToRecyclerView(null)
-
             // Add overlap decoration if not present
             if (overlapDecoration == null) {
                 overlapDecoration = OverlappingDecoration(overlapPx)
@@ -335,12 +402,7 @@ class CarouselRecyclerView @JvmOverloads constructor(
                 addOnScrollListener(scalingScrollListener!!)
             }
 
-            if (cardSize > 0) {
-                val topPadding = ((height - bottomInset - cardSize) / 2).coerceAtLeast(0) // Center vertically
-                val sidePadding = (width - cardSize) / 2 // Center first/last card
-                setPadding(sidePadding, topPadding, sidePadding, 0)
-                clipToPadding = false
-            }
+            applyCarouselPadding()
 
             if (pagerSnapHelper == null) {
                 pagerSnapHelper = CenterPagerSnapHelper()
@@ -362,6 +424,7 @@ class CarouselRecyclerView @JvmOverloads constructor(
                 }
                 savedItemAnimator = null
             }
+            cardGeometryInitialized = false
             useCustomDrawingOrder = false
             // Reset padding and fling
             setPadding(0, 0, 0, 0)

src/common/net/net.h

@@ -11,14 +11,14 @@
 
 namespace Common::Net {
 
-typedef struct {
+struct Asset {
     std::string name;
     std::string url;
     std::string path;
     std::string filename;
-} Asset;
+};
 
-typedef struct Release {
+struct Release {
     std::string title;
     std::string body;
     std::string tag;
@@ -39,7 +39,7 @@ typedef struct Release {
     static std::optional<Release> FromJson(const std::string_view& json, const std::string &host, const std::string& repo);
     static std::vector<Release> ListFromJson(const nlohmann::json &json, const std::string &host, const std::string &repo);
     static std::vector<Release> ListFromJson(const std::string_view &json, const std::string &host, const std::string &repo);
-} Release;
+};
 
 // Make a request via httplib, and return the response body if applicable.
 std::optional<std::string> MakeRequest(const std::string &url, const std::string &path);

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -168,7 +168,7 @@ void Traverse(EmitContext& ctx, IR::Program& program) {
             if (!Settings::values.disable_shader_loop_safety_checks) {
                 const Id pointer_type{ctx.TypePointer(spv::StorageClass::Private, ctx.U32[1])};
                 const Id safety_counter{ctx.AddGlobalVariable(
-                    pointer_type, spv::StorageClass::Private, ctx.Const(0x2000u))};
+                    pointer_type, spv::StorageClass::Private, ctx.Const(0x100u))};
                 if (ctx.profile.supported_spirv >= 0x00010400) {
                     ctx.interfaces.push_back(safety_counter);
                 }

src/video_core/buffer_cache/buffer_cache.h

@@ -7,7 +7,10 @@
 #pragma once
 
 #include <algorithm>
+#include <array>
+#include <cstring>
 #include <memory>
+#include <mutex>
 #include <numeric>
 
 #include "common/range_sets.inc"
@@ -215,6 +218,99 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
     auto& dest_buffer = slot_buffers[buffer_b];
     SynchronizeBuffer(src_buffer, *cpu_src_address, static_cast<u32>(amount));
     SynchronizeBuffer(dest_buffer, *cpu_dest_address, static_cast<u32>(amount));
+
+    // MHR Sunbreak PoC: replace the poisoned A/B record with its healthy peer.
+    constexpr DAddr mhr_slot_a = 0xb7e01000ULL;
+    constexpr DAddr mhr_slot_b = 0xb7a01000ULL;
+    constexpr u64 mhr_slot_size = 0x129000ULL;
+    constexpr size_t mhr_record_size = 0x70;
+    using MhrRecord = std::array<u8, mhr_record_size>;
+    struct MhrCacheEntry {
+        DAddr destination{};
+        MhrRecord a{};
+        MhrRecord b{};
+        bool has_a{};
+        bool has_b{};
+    };
+    static std::mutex mhr_mutex;
+    static std::array<MhrCacheEntry, 512> mhr_cache{};
+    static size_t mhr_cache_next{};
+
+    const auto in_mhr_slot = [&](DAddr address, DAddr slot) {
+        return amount == mhr_record_size && address >= slot &&
+               address <= slot + mhr_slot_size - mhr_record_size;
+    };
+    const bool mhr_source_a = in_mhr_slot(*cpu_src_address, mhr_slot_a);
+    const bool mhr_source_b = in_mhr_slot(*cpu_src_address, mhr_slot_b);
+    bool mhr_override{};
+    MhrRecord mhr_healthy_record{};
+    if (mhr_source_a || mhr_source_b) {
+        const auto score_record = [](const MhrRecord& record) {
+            u32 score{};
+            for (size_t offset = 0; offset < record.size(); offset += sizeof(u32)) {
+                u32 word{};
+                std::memcpy(&word, record.data() + offset, sizeof(word));
+                if (word == 0x7f7f7f7fU) {
+                    score += 64;
+                } else if (word == 0x7fffffffU || word == 0xffffffffU || word == 0x80808080U ||
+                           word == 0x81818181U) {
+                    score += 4;
+                }
+            }
+            for (size_t offset = 0; offset + sizeof(u64) <= record.size(); offset += sizeof(u64)) {
+                u32 lo{};
+                u32 hi{};
+                std::memcpy(&lo, record.data() + offset, sizeof(lo));
+                std::memcpy(&hi, record.data() + offset + sizeof(u32), sizeof(hi));
+                if (lo == 0 && hi == 0x7f7f7f7fU) {
+                    score += 128;
+                }
+            }
+            u32 first{};
+            u32 second{};
+            std::memcpy(&first, record.data() + 0x60, sizeof(first));
+            std::memcpy(&second, record.data() + 0x64, sizeof(second));
+            if ((first & 0x40000U) != 0 && (second & 0x40000U) == 0 &&
+                ((first ^ second) & 0xffffU) == 0) {
+                score += 16;
+            } else if ((first & 0x40000U) == 0 && (second & 0x40000U) != 0 &&
+                       ((first ^ second) & 0xffffU) == 0 && score >= 4) {
+                score -= 4;
+            }
+            return score;
+        };
+
+        MhrRecord source_record{};
+        device_memory.ReadBlockUnsafe(*cpu_src_address, source_record.data(), source_record.size());
+        std::scoped_lock lock{mhr_mutex};
+        auto entry = std::ranges::find_if(mhr_cache, [&](const MhrCacheEntry& current) {
+            return (current.has_a || current.has_b) && current.destination == *cpu_dest_address;
+        });
+        if (entry == mhr_cache.end()) {
+            entry = mhr_cache.begin() + mhr_cache_next++ % mhr_cache.size();
+            *entry = {};
+            entry->destination = *cpu_dest_address;
+        }
+        if (mhr_source_a) {
+            entry->a = source_record;
+            entry->has_a = true;
+        } else {
+            entry->b = source_record;
+            entry->has_b = true;
+        }
+        if (entry->has_a && entry->has_b) {
+            const u32 score_a{score_record(entry->a)};
+            const u32 score_b{score_record(entry->b)};
+            if (score_a != score_b) {
+                const bool healthy_is_a{score_a < score_b};
+                if (mhr_source_a != healthy_is_a) {
+                    mhr_healthy_record = healthy_is_a ? entry->a : entry->b;
+                    mhr_override = true;
+                }
+            }
+        }
+    }
+
     std::array copies{BufferCopy{
         .src_offset = src_buffer.Offset(*cpu_src_address),
         .dst_offset = dest_buffer.Offset(*cpu_dest_address),
@@ -244,6 +340,14 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
         memory_tracker.MarkRegionAsGpuModified(*cpu_dest_address, amount);
     }
 
+    if (mhr_override) {
+        device_memory.WriteBlockUnsafe(*cpu_dest_address, mhr_healthy_record.data(),
+                                       mhr_healthy_record.size());
+        InlineMemoryImplementation(*cpu_dest_address, mhr_healthy_record.size(),
+                                   std::span<const u8>{mhr_healthy_record});
+        return true;
+    }
+
     Tegra::Memory::DeviceGuestMemoryScoped<u8, Tegra::Memory::GuestMemoryFlags::UnsafeReadWrite>
         tmp(device_memory, *cpu_src_address, amount, &tmp_buffer);
     tmp.SetAddressAndSize(*cpu_dest_address, amount);