2026-09-06 04:05:29

Signed-off-by: lizzie <lizzie@eden-emu.dev>

CONTRIBUTING.md

@@ -83,3 +83,16 @@ Once your request is processed, you will receive a confirmation email with your
 Alongside the other contribution methods listed up top, you can also choose to contribute through documentation, organization, or community guides. These can be done either through the code contribution methods described above, or created externally and shared via our Discord community.
 
 If you have an external tool/page that you believe would be handy to integrate/link into Eden, please additionally email our developers at [`developers@eden-emu.dev`](mailto:developers@eden-emu.dev). **Do not submit vibe-coded or AI generated tools or applications**.
+
+### Non-English Contributions
+
+If you can't speak English or find more comfortable speaking in your native tongue, you may submit PR, commits, comments, and reviews in other languages. There is no restriction what languages are allowed, but maintainers will use translators if they're unable to understand.
+
+Triage can speak:
+
+- Chinese
+- Portuguese
+- Russian
+- Spanish
+
+Documentation must be in American English, we don't have the capacity to support multilingual manuals. Code comments must remain in English for future referral.

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -30,7 +30,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
-    ENABLE_SHADER_PHI_TRACKING("enable_shader_phi_tracking"),
     ENABLE_GPU_BUFFER_READBACK("enable_gpu_buffer_readback"),
     SYNC_MEMORY_OPERATIONS("sync_memory_operations"),
     BUFFER_REORDER_DISABLE("disable_buffer_reorder"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -927,13 +927,6 @@ abstract class SettingsItem(
                     descriptionId = R.string.use_optimized_vertex_buffers_description
                 )
             )
-            put(
-                SwitchSetting(
-                    BooleanSetting.ENABLE_SHADER_PHI_TRACKING,
-                    titleId = R.string.enable_shader_phi_tracking,
-                    descriptionId = R.string.enable_shader_phi_tracking_description
-                )
-            )
             put(
                 SwitchSetting(
                     BooleanSetting.SYNC_MEMORY_OPERATIONS,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -338,7 +338,6 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.ENABLE_BUFFER_HISTORY.key)
             add(BooleanSetting.ENABLE_GPU_BUFFER_READBACK.key)
             add(BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS.key)
-            add(BooleanSetting.ENABLE_SHADER_PHI_TRACKING.key)
 
             add(HeaderSetting(R.string.hacks))
 

src/android/app/src/main/res/values/strings.xml

@@ -570,8 +570,6 @@
     <string name="enable_gpu_buffer_readback_description">Preserves GPU-modified buffer data by reading it back before uploads. Some games require this to render certain effects properly. May cause issues if the hardware cannot handle the additional workload.</string>
     <string name="use_optimized_vertex_buffers">Optimized Vertex Buffers</string>
     <string name="use_optimized_vertex_buffers_description">Enables optimized vertex buffer binding for improved performance. Requires Mesa 26.0+ Turnip drivers/ QCOM drivers. Will crash on older Turnip drivers (25.3 and below).</string>
-    <string name="enable_shader_phi_tracking">Shader Phi Tracking</string>
-    <string name="enable_shader_phi_tracking_description">toggle for test on shader phi tracking.</string>
 
     <string name="hacks">Hacks</string>
 

src/common/settings.h

@@ -592,14 +592,6 @@ struct Values {
                                                   true,
                                                   true};
 
-    SwitchableSetting<bool> enable_shader_phi_tracking{linkage,
-                                                       true,
-                                                       "enable_shader_phi_tracking",
-                                                       Category::RendererAdvanced,
-                                                       Specialization::Default,
-                                                       true,
-                                                       true};
-
 #ifdef __ANDROID__
     SwitchableSetting<bool> use_optimized_vertex_buffers{linkage,
                                                  false,

src/qt_common/config/shared_translation.cpp

@@ -267,8 +267,6 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
     INSERT(Settings, enable_buffer_history, tr("Enable buffer history"),
            tr("Enables access to previous buffer states.\nThis option may improve rendering "
               "quality and performance consistency in some games."));
-    INSERT(Settings, enable_shader_phi_tracking, tr("Shader phi tracking"),
-           tr("toggle for test on shader phi tracking."));
     INSERT(Settings, fix_bloom_effects, tr("Fix bloom effects"), tr("Removes bloom in Burnout."));
 
     INSERT(Settings, rescale_hack, tr("Enable Legacy Rescale Pass"),

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -299,128 +299,23 @@ static inline bool IsTexturePixelFormatIntegerCached(Environment& env,
 }
 
 
-constexpr size_t PHI_TRACK_MAX_DEPTH = 3;
-
-struct PhiTrackState {
-    boost::container::small_vector<const IR::Inst*, 8> active;
-    size_t depth{};
-};
-
-std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env,
-                                     const HostTranslateInfo& host_info, PhiTrackState& state);
-static inline std::optional<ConstBufferAddr> TrackCached(const IR::Value& v, Environment& env,
-                                                         const HostTranslateInfo& host_info,
-                                                         PhiTrackState& state) {
+std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env, const HostTranslateInfo& host_info);
+static inline std::optional<ConstBufferAddr> TrackCached(const IR::Value& v, Environment& env, const HostTranslateInfo& host_info) {
     if (const IR::Inst* key = v.InstRecursive()) {
         if (auto it = env.track_cache.find(key); it != env.track_cache.end()) return it->second;
-        auto found = Track(v, env, host_info, state);
+        auto found = Track(v, env, host_info);
         if (found) env.track_cache.emplace(key, *found);
         return found;
     }
-    return Track(v, env, host_info, state);
+    return Track(v, env, host_info);
 }
 
-std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env,
-                                                 const HostTranslateInfo& host_info,
-                                                 PhiTrackState& state);
+std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env, const HostTranslateInfo& host_info);
 
-bool IsSameConstBufferAddr(const ConstBufferAddr& lhs, const ConstBufferAddr& rhs) {
-    return lhs.index == rhs.index && lhs.offset == rhs.offset &&
-           lhs.shift_left == rhs.shift_left && lhs.secondary_index == rhs.secondary_index &&
-           lhs.secondary_offset == rhs.secondary_offset &&
-           lhs.secondary_shift_left == rhs.secondary_shift_left && lhs.count == rhs.count &&
-           lhs.has_secondary == rhs.has_secondary && lhs.dynamic_offset == rhs.dynamic_offset;
-}
-
-std::optional<ConstBufferAddr> TrackUncached(const IR::Value& value, Environment& env,
-                                             const HostTranslateInfo& host_info,
-                                             PhiTrackState& state, bool& ambiguous);
-
-std::optional<ConstBufferAddr> TrackPhi(const IR::Inst* phi, Environment& env,
-                                        const HostTranslateInfo& host_info, PhiTrackState& state,
-                                        bool& ambiguous) {
-    if (state.depth >= PHI_TRACK_MAX_DEPTH) {
-        ambiguous = true;
-        return std::nullopt;
-    }
-    if (std::ranges::find(state.active, phi) != state.active.end()) {
-        return std::nullopt;
-    }
-    state.active.push_back(phi);
-    ++state.depth;
-
-    std::optional<ConstBufferAddr> agreed;
-    bool failed = false;
-    const size_t num_args{phi->NumArgs()};
-    for (size_t index = 0; index < num_args; ++index) {
-        const IR::Value arg{phi->Arg(index).Resolve()};
-        if (arg.IsImmediate()) {
-            failed = true;
-            break;
-        }
-        const IR::Inst* arg_inst{arg.InstRecursive()};
-        if (arg_inst == phi) {
-            continue;
-        }
-        if (std::ranges::find(state.active, arg_inst) != state.active.end()) {
-            continue;
-        }
-        bool operand_ambiguous = false;
-        const std::optional<ConstBufferAddr> operand{
-            TrackUncached(arg, env, host_info, state, operand_ambiguous)};
-        if (!operand || operand_ambiguous) {
-            failed = true;
-            break;
-        }
-        if (!agreed) {
-            agreed = operand;
-            continue;
-        }
-        if (!IsSameConstBufferAddr(*agreed, *operand)) {
-            failed = true;
-            break;
-        }
-    }
-
-    --state.depth;
-    state.active.pop_back();
-
-    if (failed || !agreed) {
-        ambiguous = true;
-        return std::nullopt;
-    }
-    return agreed;
-}
-
-std::optional<ConstBufferAddr> TrackUncached(const IR::Value& value, Environment& env,
-                                             const HostTranslateInfo& host_info,
-                                             PhiTrackState& state, bool& ambiguous) {
-    return IR::BreadthFirstSearch(
-        value, [&env, &host_info, &state, &ambiguous](
-                   const IR::Inst* inst) -> std::optional<ConstBufferAddr> {
-            if (inst->GetOpcode() == IR::Opcode::Phi) {
-                return TrackPhi(inst, env, host_info, state, ambiguous);
-            }
-            return TryGetConstBuffer(inst, env, host_info, state);
-        });
-}
-
-std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env,
-                                     const HostTranslateInfo& host_info, PhiTrackState& state) {
-    if (!Settings::values.enable_shader_phi_tracking.GetValue()) {
-        return IR::BreadthFirstSearch(
-            value, [&env, &host_info, &state](
-                       const IR::Inst* inst) -> std::optional<ConstBufferAddr> {
-                return TryGetConstBuffer(inst, env, host_info, state);
-            });
-    }
-    bool ambiguous = false;
-    const std::optional<ConstBufferAddr> result{
-        TrackUncached(value, env, host_info, state, ambiguous)};
-    if (ambiguous) {
-        return std::nullopt;
-    }
-    return result;
+std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env, const HostTranslateInfo& host_info) {
+    return IR::BreadthFirstSearch(value, [&env, &host_info](const IR::Inst* inst) {
+        return TryGetConstBuffer(inst, env, host_info);
+    });
 }
 
 std::optional<u32> TryGetConstant(IR::Value& value, Environment& env) {
@@ -444,15 +339,13 @@ std::optional<u32> TryGetConstant(IR::Value& value, Environment& env) {
     return ReadCbufCached(env, index_number, offset_number);
 }
 
-std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env,
-                                                 const HostTranslateInfo& host_info,
-                                                 PhiTrackState& state) {
+std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env, const HostTranslateInfo& host_info) {
     switch (inst->GetOpcode()) {
     default:
         return std::nullopt;
     case IR::Opcode::BitwiseOr32: {
-        std::optional lhs{TrackCached(inst->Arg(0), env, host_info, state)};
-        std::optional rhs{TrackCached(inst->Arg(1), env, host_info, state)};
+        std::optional lhs{TrackCached(inst->Arg(0), env, host_info)};
+        std::optional rhs{TrackCached(inst->Arg(1), env, host_info)};
         if (!lhs || !rhs) {
             return std::nullopt;
         }
@@ -482,7 +375,7 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
         if (!shift.IsImmediate()) {
             return std::nullopt;
         }
-        std::optional lhs{TrackCached(inst->Arg(0), env, host_info, state)};
+        std::optional lhs{TrackCached(inst->Arg(0), env, host_info)};
         if (lhs) {
             lhs->shift_left = shift.U32();
         }
@@ -510,7 +403,7 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
                 return std::nullopt;
             } while (false);
         }
-        std::optional lhs{TrackCached(op1, env, host_info, state)};
+        std::optional lhs{TrackCached(op1, env, host_info)};
         if (lhs) {
             lhs->shift_left = static_cast<u32>(std::countr_zero(op2.U32()));
         }
@@ -576,9 +469,7 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
 TextureInst MakeInst(Environment& env, IR::Block* block, IR::Inst& inst, const HostTranslateInfo& host_info) {
     ConstBufferAddr addr;
     if (IsBindless(inst)) {
-        PhiTrackState state;
-        const std::optional<ConstBufferAddr> track_addr{
-            TrackCached(inst.Arg(0), env, host_info, state)};
+        const std::optional<ConstBufferAddr> track_addr{TrackCached(inst.Arg(0), env, host_info)};
 
         if (!track_addr) {
             throw NotImplementedException("Failed to track bindless texture constant buffer");

src/video_core/CMakeLists.txt

@@ -20,7 +20,6 @@ add_library(video_core STATIC
     buffer_cache/buffer_cache.h
     buffer_cache/memory_tracker_base.h
     buffer_cache/usage_tracker.h
-    buffer_cache/virtual_range_cache.h
     buffer_cache/word_manager.h
     cache_types.h
     capture.h
@@ -167,8 +166,6 @@ add_library(video_core STATIC
     renderer_vulkan/vk_fence_manager.h
     renderer_vulkan/vk_graphics_pipeline.cpp
     renderer_vulkan/vk_graphics_pipeline.h
-    renderer_vulkan/vk_multi_range_buffer.cpp
-    renderer_vulkan/vk_multi_range_buffer.h
     renderer_vulkan/vk_master_semaphore.cpp
     renderer_vulkan/vk_master_semaphore.h
     renderer_vulkan/vk_pipeline_cache.cpp

src/video_core/buffer_cache/buffer_cache.h

@@ -112,13 +112,6 @@ void BufferCache<P>::TickFrame() {
     async_buffers_death_ring.clear();
 }
 
-template <class P>
-void BufferCache<P>::UnmapGPUMemory(size_t as_id, GPUVAddr gpu_addr, size_t size) {
-    if constexpr (requires { runtime.BindMultiRangeStorageBuffer(u64{}); }) {
-        virtual_ranges.Unmap(as_id, gpu_addr, size);
-    }
-}
-
 template <class P>
 void BufferCache<P>::WriteMemory(DAddr device_addr, u64 size) {
     if (memory_tracker.IsRegionGpuModified(device_addr, size)) {
@@ -1005,85 +998,11 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
     channel_state->fast_bound_uniform_buffers[stage] &= ~(1u << binding_index);
 }
 
-template <class P>
-void BufferCache<P>::ResolveMultiRangeStorage(Binding& binding, bool is_written,
-                                              std::vector<MultiRangeSegment>& pool) {
-    binding.segment_first = 0;
-    binding.segment_count = 0;
-    if constexpr (requires { runtime.BindMultiRangeStorageBuffer(u64{}); }) {
-        if (binding.gpu_addr == 0 || binding.size == 0) {
-            return;
-        }
-        if (is_written && !runtime.PrefersSparseSources()) {
-            return;
-        }
-        const VirtualSegments* found =
-            virtual_ranges.Query(*gpu_memory, binding.gpu_addr, binding.size);
-        if (!found || found->size() < 2) {
-            return;
-        }
-        const VirtualSegments segments = *found;
-        const u32 first = static_cast<u32>(pool.size());
-        const bool prefer_sparse = runtime.PrefersSparseSources();
-        for (const VirtualSegment& segment : segments) {
-            const BufferId buffer_id =
-                FindBuffer(segment.device_addr, segment.size, prefer_sparse);
-            if (!buffer_id) {
-                pool.resize(first);
-                return;
-            }
-            pool.push_back(MultiRangeSegment{
-                .buffer_id = buffer_id,
-                .device_addr = segment.device_addr,
-                .size = segment.size,
-            });
-        }
-        binding.segment_first = first;
-        binding.segment_count = static_cast<u32>(segments.size());
-    }
-}
-
-template <class P>
-bool BufferCache<P>::BindMultiRangeStorage(const Binding& binding, bool is_written,
-                                           std::span<const MultiRangeSegment> pool) {
-    if constexpr (requires { runtime.BindMultiRangeStorageBuffer(u64{}); }) {
-        if (binding.segment_count < 2) {
-            return false;
-        }
-        if (binding.segment_first + binding.segment_count > pool.size()) {
-            return false;
-        }
-        const u64 key = (static_cast<u64>(gpu_memory->GetID()) << 48) ^ binding.gpu_addr;
-        runtime.ResetMultiRange();
-        for (u32 index = 0; index < binding.segment_count; ++index) {
-            const MultiRangeSegment& segment = pool[binding.segment_first + index];
-            Buffer& buffer = slot_buffers[segment.buffer_id];
-            TouchBuffer(buffer, segment.buffer_id);
-            if (SynchronizeBuffer(buffer, segment.device_addr, segment.size)) {
-                runtime.InvalidateMultiRange(key);
-            }
-            const u32 offset = buffer.Offset(segment.device_addr);
-            buffer.MarkUsage(offset, segment.size);
-            if (is_written) {
-                MarkWrittenBuffer(segment.buffer_id, segment.device_addr, segment.size);
-            }
-            runtime.PushMultiRangeSource(buffer, offset, segment.size);
-        }
-        return runtime.BindMultiRangeStorageBuffer(key);
-    } else {
-        return false;
-    }
-}
-
 template <class P>
 void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
     u32 binding_index = 0;
     ForEachEnabledBit(channel_state->enabled_storage_buffers[stage], [&](u32 index) {
         const Binding& binding = channel_state->storage_buffers[stage][index];
-        const bool is_written = ((channel_state->written_storage_buffers[stage] >> index) & 1) != 0;
-        if (BindMultiRangeStorage(binding, is_written, graphics_segments)) {
-            return;
-        }
         Buffer& buffer = slot_buffers[binding.buffer_id];
         TouchBuffer(buffer, binding.buffer_id);
         const u32 size = binding.size;
@@ -1091,6 +1010,7 @@ void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
 
         const u32 offset = buffer.Offset(binding.device_addr);
         buffer.MarkUsage(offset, size);
+        const bool is_written = ((channel_state->written_storage_buffers[stage] >> index) & 1) != 0;
 
         if (is_written) {
             MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
@@ -1219,11 +1139,6 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
     u32 binding_index = 0;
     ForEachEnabledBit(channel_state->enabled_compute_storage_buffers, [&](u32 index) {
         const Binding& binding = channel_state->compute_storage_buffers[index];
-        const bool is_written =
-            ((channel_state->written_compute_storage_buffers >> index) & 1) != 0;
-        if (BindMultiRangeStorage(binding, is_written, compute_segments)) {
-            return;
-        }
         Buffer& buffer = slot_buffers[binding.buffer_id];
         TouchBuffer(buffer, binding.buffer_id);
         const u32 size = binding.size;
@@ -1231,6 +1146,8 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
 
         const u32 offset = buffer.Offset(binding.device_addr);
         buffer.MarkUsage(offset, size);
+        const bool is_written =
+            ((channel_state->written_compute_storage_buffers >> index) & 1) != 0;
 
         if (is_written) {
             MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
@@ -1276,7 +1193,6 @@ void BufferCache<P>::BindHostComputeTextureBuffers() {
 
 template <class P>
 void BufferCache<P>::DoUpdateGraphicsBuffers(bool is_indexed) {
-    graphics_segments.clear();
     BufferOperations([&]() {
         if (is_indexed) {
             UpdateIndexBuffer();
@@ -1296,7 +1212,6 @@ void BufferCache<P>::DoUpdateGraphicsBuffers(bool is_indexed) {
 
 template <class P>
 void BufferCache<P>::DoUpdateComputeBuffers() {
-    compute_segments.clear();
     BufferOperations([&]() {
         UpdateComputeUniformBuffers();
         UpdateComputeStorageBuffers();
@@ -1439,8 +1354,6 @@ void BufferCache<P>::UpdateStorageBuffers(size_t stage) {
         Binding& binding = channel_state->storage_buffers[stage][index];
         const BufferId buffer_id = FindBuffer(binding.device_addr, binding.size);
         binding.buffer_id = buffer_id;
-        const bool is_written = ((channel_state->written_storage_buffers[stage] >> index) & 1) != 0;
-        ResolveMultiRangeStorage(binding, is_written, graphics_segments);
     });
 }
 
@@ -1504,9 +1417,6 @@ void BufferCache<P>::UpdateComputeStorageBuffers() {
         // Resolve buffer
         Binding& binding = channel_state->compute_storage_buffers[index];
         binding.buffer_id = FindBuffer(binding.device_addr, binding.size);
-        const bool is_written =
-            ((channel_state->written_compute_storage_buffers >> index) & 1) != 0;
-        ResolveMultiRangeStorage(binding, is_written, compute_segments);
     });
 }
 
@@ -1530,7 +1440,7 @@ void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u3
 }
 
 template <class P>
-BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size, bool sparse_compatible) {
+BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size) {
     if (device_addr == 0) {
         return NULL_BUFFER_ID;
     }
@@ -1540,18 +1450,10 @@ BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size, bool sparse_com
         Buffer& buffer = slot_buffers[buffer_id];
         WaitForGpuFenceIfNeeded(buffer);
         if (buffer.IsInBounds(device_addr, size)) {
-            bool usable = true;
-            if constexpr (requires { buffer.IsSparseCompatible(); }) {
-                if (sparse_compatible && !buffer.IsSparseCompatible()) {
-                    usable = false;
-                }
-            }
-            if (usable) {
-                return buffer_id;
-            }
+            return buffer_id;
         }
     }
-    return CreateBuffer(device_addr, size, sparse_compatible);
+    return CreateBuffer(device_addr, size);
 }
 
 template <class P>
@@ -1673,15 +1575,13 @@ void BufferCache<P>::JoinOverlap(BufferId new_buffer_id, BufferId overlap_id,
 }
 
 template <class P>
-BufferId BufferCache<P>::CreateBuffer(DAddr device_addr, u32 wanted_size,
-                                      bool sparse_compatible) {
+BufferId BufferCache<P>::CreateBuffer(DAddr device_addr, u32 wanted_size) {
     DAddr device_addr_end = Common::AlignUp(device_addr + wanted_size, CACHING_PAGESIZE);
     device_addr = Common::AlignDown(device_addr, CACHING_PAGESIZE);
     wanted_size = static_cast<u32>(device_addr_end - device_addr);
     const OverlapResult overlap = ResolveOverlaps(device_addr, wanted_size);
     const u32 size = static_cast<u32>(overlap.end - overlap.begin);
-    const BufferId new_buffer_id =
-        slot_buffers.insert(runtime, overlap.begin, size, sparse_compatible);
+    const BufferId new_buffer_id = slot_buffers.insert(runtime, overlap.begin, size);
     auto& new_buffer = slot_buffers[new_buffer_id];
     const size_t size_bytes = new_buffer.SizeBytes();
     runtime.ClearBuffer(new_buffer, 0, size_bytes, 0);
@@ -1931,9 +1831,6 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64
 
 template <class P>
 void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
-    if constexpr (requires { runtime.OnBufferDeleted(slot_buffers[buffer_id]); }) {
-        runtime.OnBufferDeleted(slot_buffers[buffer_id]);
-    }
     bool dirty_index{false};
     boost::container::small_vector<u64, NUM_VERTEX_BUFFERS> dirty_vertex_buffers;
     const auto scalar_replace = [buffer_id](Binding& binding) {
@@ -2037,15 +1934,10 @@ Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
     // The end address used for size calculation does not need to be aligned
     const DAddr cpu_end = Common::AlignUp(*device_addr + size, Core::DEVICE_PAGESIZE);
 
-    u32 binding_size = static_cast<u32>(cpu_end - *aligned_device_addr);
-    if (is_written) {
-        binding_size = aligned_size;
-    }
     const Binding binding{
         .device_addr = *aligned_device_addr,
-        .size = binding_size,
+        .size = is_written ? aligned_size : static_cast<u32>(cpu_end - *aligned_device_addr),
         .buffer_id = BufferId{},
-        .gpu_addr = aligned_gpu_addr,
     };
     return binding;
 }

src/video_core/buffer_cache/buffer_cache_base.h

@@ -29,7 +29,6 @@
 #include "common/settings.h"
 #include "common/slot_vector.h"
 #include "video_core/buffer_cache/buffer_base.h"
-#include "video_core/buffer_cache/virtual_range_cache.h"
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/delayed_destruction_ring.h"
 #include "video_core/dirty_flags.h"
@@ -84,15 +83,6 @@ struct Binding {
     DAddr device_addr{};
     u32 size{};
     BufferId buffer_id;
-    GPUVAddr gpu_addr{};
-    u32 segment_first{};
-    u32 segment_count{};
-};
-
-struct MultiRangeSegment {
-    BufferId buffer_id;
-    DAddr device_addr{};
-    u32 size{};
 };
 
 struct TextureBufferBinding : Binding {
@@ -225,14 +215,6 @@ public:
 
     void TickFrame();
 
-    bool BindMultiRangeStorage(const Binding& binding, bool is_written,
-                               std::span<const MultiRangeSegment> pool);
-
-    void ResolveMultiRangeStorage(Binding& binding, bool is_written,
-                                  std::vector<MultiRangeSegment>& pool);
-
-    void UnmapGPUMemory(size_t as_id, GPUVAddr gpu_addr, size_t size);
-
     void WriteMemory(DAddr device_addr, u64 size);
 
     void CachedWriteMemory(DAddr device_addr, u64 size);
@@ -432,8 +414,7 @@ private:
 
     void MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size);
 
-    [[nodiscard]] BufferId FindBuffer(DAddr device_addr, u32 size,
-                                      bool sparse_compatible = false);
+    [[nodiscard]] BufferId FindBuffer(DAddr device_addr, u32 size);
 
     void WaitForGpuFenceIfNeeded(Buffer& buffer);
 
@@ -441,8 +422,7 @@ private:
 
     void JoinOverlap(BufferId new_buffer_id, BufferId overlap_id, bool accumulate_stream_score);
 
-    [[nodiscard]] BufferId CreateBuffer(DAddr device_addr, u32 wanted_size,
-                                        bool sparse_compatible = false);
+    [[nodiscard]] BufferId CreateBuffer(DAddr device_addr, u32 wanted_size);
 
     void Register(BufferId buffer_id);
 
@@ -534,9 +514,6 @@ private:
     };
     Common::LeastRecentlyUsedCache<LRUItemParams> lru_cache;
     u64 frame_tick = 0;
-    VirtualRangeCache virtual_ranges;
-    std::vector<MultiRangeSegment> graphics_segments;
-    std::vector<MultiRangeSegment> compute_segments;
     u64 total_used_memory = 0;
     u64 minimum_memory = 0;
     u64 critical_memory = 0;

src/video_core/buffer_cache/virtual_range_cache.h

@@ -1,163 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <atomic>
-#include <limits>
-#include <mutex>
-#include <optional>
-#include <unordered_map>
-#include <vector>
-
-#include <boost/container/small_vector.hpp>
-
-#include "common/common_types.h"
-#include "video_core/memory_manager.h"
-
-namespace VideoCommon {
-
-struct VirtualSegment {
-    GPUVAddr gpu_addr;
-    DAddr device_addr;
-    u32 size;
-};
-
-using VirtualSegments = boost::container::small_vector<VirtualSegment, 8>;
-
-class VirtualRangeCache {
-public:
-    const VirtualSegments* Query(Tegra::MemoryManager& memory, GPUVAddr gpu_addr, u32 size) {
-        if (has_deferred.load(std::memory_order_acquire)) {
-            ApplyDeferred();
-        }
-        const size_t as_id = memory.GetID();
-        const u64 key = MakeKey(as_id, gpu_addr);
-        const auto it = entries.find(key);
-        if (it != entries.end() && it->second.as_id == as_id &&
-            it->second.gpu_addr == gpu_addr && it->second.size == size) {
-            return &it->second.segments;
-        }
-        Entry entry;
-        entry.as_id = as_id;
-        entry.gpu_addr = gpu_addr;
-        entry.size = size;
-        const auto ranges = memory.GetSubmappedRange(gpu_addr, size);
-        GPUVAddr expected = gpu_addr;
-        bool contiguous = true;
-        for (const auto& [range_addr, range_size] : ranges) {
-            if (range_addr != expected || range_size == 0) {
-                contiguous = false;
-                break;
-            }
-            const std::optional<DAddr> device_addr = memory.GpuToCpuAddress(range_addr);
-            if (!device_addr || *device_addr == 0) {
-                contiguous = false;
-                break;
-            }
-            if (range_size > static_cast<size_t>((std::numeric_limits<u32>::max)())) {
-                contiguous = false;
-                break;
-            }
-            entry.segments.push_back(VirtualSegment{
-                .gpu_addr = range_addr,
-                .device_addr = *device_addr,
-                .size = static_cast<u32>(range_size),
-            });
-            expected += range_size;
-        }
-        if (!contiguous || expected != gpu_addr + size) {
-            entry.segments.clear();
-        }
-        const auto result = entries.insert_or_assign(key, std::move(entry));
-        return &result.first->second.segments;
-    }
-
-    void Unmap(size_t as_id, GPUVAddr gpu_addr, u64 size) {
-        if (size == 0) {
-            return;
-        }
-        {
-            std::scoped_lock lock{deferred_mutex};
-            if (!deferred.empty()) {
-                DeferredUnmap& last = deferred.back();
-                if (last.as_id == as_id && last.gpu_addr + last.size == gpu_addr) {
-                    last.size += size;
-                    has_deferred.store(true, std::memory_order_release);
-                    return;
-                }
-            }
-            deferred.push_back(DeferredUnmap{
-                .as_id = as_id,
-                .gpu_addr = gpu_addr,
-                .size = size,
-            });
-        }
-        has_deferred.store(true, std::memory_order_release);
-    }
-
-    void Clear() {
-        {
-            std::scoped_lock lock{deferred_mutex};
-            deferred.clear();
-        }
-        has_deferred.store(false, std::memory_order_release);
-        entries.clear();
-    }
-
-private:
-    struct Entry {
-        size_t as_id{};
-        GPUVAddr gpu_addr{};
-        u32 size{};
-        VirtualSegments segments;
-    };
-
-    struct DeferredUnmap {
-        size_t as_id;
-        GPUVAddr gpu_addr;
-        u64 size;
-    };
-
-    static u64 MakeKey(size_t as_id, GPUVAddr gpu_addr) {
-        return (static_cast<u64>(as_id) << 48) ^ gpu_addr;
-    }
-
-    void ApplyDeferred() {
-        std::vector<DeferredUnmap> pending;
-        {
-            std::scoped_lock lock{deferred_mutex};
-            has_deferred.store(false, std::memory_order_release);
-            pending.swap(deferred);
-        }
-        if (pending.empty() || entries.empty()) {
-            return;
-        }
-        for (auto it = entries.begin(); it != entries.end();) {
-            const Entry& entry = it->second;
-            const GPUVAddr entry_end = entry.gpu_addr + entry.size;
-            bool overlaps = false;
-            for (const DeferredUnmap& unmap : pending) {
-                if (unmap.as_id != entry.as_id) {
-                    continue;
-                }
-                if (entry.gpu_addr < unmap.gpu_addr + unmap.size && unmap.gpu_addr < entry_end) {
-                    overlaps = true;
-                    break;
-                }
-            }
-            if (overlaps) {
-                it = entries.erase(it);
-            } else {
-                ++it;
-            }
-        }
-    }
-
-    std::unordered_map<u64, Entry> entries;
-    std::vector<DeferredUnmap> deferred;
-    std::mutex deferred_mutex;
-    std::atomic<bool> has_deferred{false};
-};
-
-} // namespace VideoCommon

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -52,7 +52,7 @@ constexpr std::array PROGRAM_LUT{
 Buffer::Buffer(BufferCacheRuntime&, VideoCommon::NullBufferParams null_params)
     : VideoCommon::BufferBase(null_params) {}
 
-Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_, bool)
+Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_)
     : VideoCommon::BufferBase(cpu_addr_, size_bytes_) {
     buffer.Create();
     if (runtime.device.HasDebuggingToolAttached()) {

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -23,8 +23,7 @@ class BufferCacheRuntime;
 
 class Buffer : public VideoCommon::BufferBase {
 public:
-    explicit Buffer(BufferCacheRuntime&, DAddr cpu_addr, u64 size_bytes,
-                    bool sparse_compatible = false);
+    explicit Buffer(BufferCacheRuntime&, DAddr cpu_addr, u64 size_bytes);
     explicit Buffer(BufferCacheRuntime&, VideoCommon::NullBufferParams);
 
     void ImmediateUpload(size_t offset, std::span<const u8> data) noexcept;

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -56,8 +56,7 @@ size_t BytesPerIndex(VkIndexType index_type) {
     }
 }
 
-vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allocator, u64 size,
-                        VkDeviceSize sparse_alignment) {
+vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allocator, u64 size) {
     VkBufferUsageFlags flags =
         VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
         VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT |
@@ -83,9 +82,6 @@ vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allo
         .queueFamilyIndexCount = 0,
         .pQueueFamilyIndices = nullptr,
     };
-    if (sparse_alignment > 1) {
-        return memory_allocator.CreateBuffer(buffer_ci, MemoryUsage::DeviceLocal, sparse_alignment);
-    }
     return memory_allocator.CreateBuffer(buffer_ci, MemoryUsage::DeviceLocal);
 }
 } // Anonymous namespace
@@ -103,14 +99,10 @@ Buffer::Buffer(BufferCacheRuntime& runtime, VideoCommon::NullBufferParams null_p
     }
 }
 
-Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_,
-               bool sparse_compatible_)
+Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_)
     : VideoCommon::BufferBase(cpu_addr_, size_bytes_), device{&runtime.device},
       scheduler{&runtime.scheduler},
-      buffer{CreateBuffer(*device, runtime.memory_allocator, SizeBytes(),
-                          runtime.SparseAlignmentFor(sparse_compatible_))},
-      tracker{SizeBytes()} {
-    sparse_compatible = sparse_compatible_;
+      buffer{CreateBuffer(*device, runtime.memory_allocator, SizeBytes())}, tracker{SizeBytes()} {
     if (runtime.device.HasDebuggingToolAttached()) {
         buffer.SetObjectNameEXT(fmt::format("Buffer {:#x}", CpuAddr()).c_str());
     }
@@ -356,8 +348,7 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
     : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
       staging_pool{staging_pool_}, guest_descriptor_queue{guest_descriptor_queue_},
       quad_index_pass(device, scheduler, descriptor_pool, staging_pool,
-                      compute_pass_descriptor_queue),
-      multi_range_buffers(device_, memory_allocator_, scheduler_) {
+                      compute_pass_descriptor_queue) {
     const VkDriverIdKHR driver_id = device.GetDriverID();
     limit_dynamic_storage_buffers = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
                                     driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
@@ -545,33 +536,6 @@ void BufferCacheRuntime::ClearBuffer(VkBuffer dest_buffer, u32 offset, size_t si
     });
 }
 
-bool BufferCacheRuntime::BindMultiRangeStorageBuffer(u64 key) {
-    if (multi_range_sources.empty() || multi_range_total == 0) {
-        return false;
-    }
-    const MultiRangeRef ref = multi_range_buffers.Get(key, multi_range_sources, multi_range_total);
-    if (ref.handle == VK_NULL_HANDLE) {
-        return false;
-    }
-    if (ref.needs_gather) {
-        PreCopyBarrier();
-        VkDeviceSize dst_offset = 0;
-        for (const MultiRangeSource& source : multi_range_sources) {
-            const std::array<VideoCommon::BufferCopy, 1> copy{VideoCommon::BufferCopy{
-                .src_offset = static_cast<u64>(source.offset),
-                .dst_offset = static_cast<u64>(dst_offset),
-                .size = static_cast<size_t>(source.size),
-            }};
-            CopyBuffer(ref.handle, source.handle, copy, false);
-            dst_offset += source.size;
-        }
-        PostCopyBarrier();
-        multi_range_buffers.MarkGathered(key);
-    }
-    guest_descriptor_queue.AddBuffer(ref.handle, ref.address, 0, ref.size);
-    return true;
-}
-
 void BufferCacheRuntime::BindIndexBuffer(PrimitiveTopology topology, IndexFormat index_format,
                                          u32 base_vertex, u32 num_indices, VkBuffer buffer,
                                          u32 offset, [[maybe_unused]] u32 size) {

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -8,14 +8,11 @@
 
 #include <limits>
 
-#include <boost/container/small_vector.hpp>
-
 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/buffer_cache/memory_tracker_base.h"
 #include "video_core/buffer_cache/usage_tracker.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_vulkan/vk_compute_pass.h"
-#include "video_core/renderer_vulkan/vk_multi_range_buffer.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/surface.h"
@@ -34,8 +31,7 @@ class BufferCacheRuntime;
 class Buffer : public VideoCommon::BufferBase {
 public:
     explicit Buffer(BufferCacheRuntime&, VideoCommon::NullBufferParams null_params);
-    explicit Buffer(BufferCacheRuntime& runtime, VAddr cpu_addr_, u64 size_bytes_,
-                    bool sparse_compatible_ = false);
+    explicit Buffer(BufferCacheRuntime& runtime, VAddr cpu_addr_, u64 size_bytes_);
 
     [[nodiscard]] VkBufferView View(u32 offset, u32 size, VideoCore::Surface::PixelFormat format);
 
@@ -47,14 +43,6 @@ public:
         return device_address;
     }
 
-    [[nodiscard]] bool IsSparseCompatible() const noexcept {
-        return sparse_compatible;
-    }
-
-    [[nodiscard]] vk::MemoryLocation Location() const noexcept {
-        return buffer.Location();
-    }
-
     [[nodiscard]] bool IsRegionUsed(u64 offset, u64 size) const noexcept {
         return tracker.IsUsed(offset, size);
     }
@@ -89,7 +77,6 @@ private:
     VkDeviceAddress device_address{};
     u64 last_usage_tick{};
     bool is_null{};
-    bool sparse_compatible{};
 };
 
 class QuadArrayIndexBuffer;
@@ -138,7 +125,7 @@ public:
 
     void PreCopyBarrier();
 
-    void CopyBuffer(VkBuffer dst_buffer, VkBuffer src_buffer,
+    void CopyBuffer(VkBuffer src_buffer, VkBuffer dst_buffer,
                     std::span<const VideoCommon::BufferCopy> copies, bool barrier,
                     bool can_reorder_upload = false);
 
@@ -168,45 +155,6 @@ public:
         return ref.mapped_span;
     }
 
-    [[nodiscard]] VkDeviceSize SparseAlignmentFor(bool sparse_compatible) const noexcept {
-        if (!sparse_compatible || !multi_range_buffers.UsesSparse()) {
-            return 0;
-        }
-        return multi_range_buffers.BlockSize();
-    }
-
-    [[nodiscard]] bool PrefersSparseSources() const noexcept {
-        return multi_range_buffers.UsesSparse();
-    }
-
-    void ResetMultiRange() noexcept {
-        multi_range_sources.clear();
-        multi_range_total = 0;
-    }
-
-    void PushMultiRangeSource(const Buffer& buffer, u32 offset, u32 size) {
-        const vk::MemoryLocation location = buffer.Location();
-        multi_range_sources.push_back(MultiRangeSource{
-            .handle = buffer.Handle(),
-            .memory = location.memory,
-            .memory_offset = location.offset,
-            .offset = offset,
-            .size = size,
-            .memory_type = location.memory_type,
-        });
-        multi_range_total += size;
-    }
-
-    bool BindMultiRangeStorageBuffer(u64 key);
-
-    void InvalidateMultiRange(u64 key) {
-        multi_range_buffers.Invalidate(key);
-    }
-
-    void OnBufferDeleted(const Buffer& buffer) {
-        multi_range_buffers.DropOwner(buffer.Handle());
-    }
-
     void BindUniformBuffer(const Buffer& buffer, u32 offset, u32 size) {
         BindBuffer(buffer, offset, size);
     }
@@ -260,10 +208,6 @@ private:
     std::unique_ptr<Uint8Pass> uint8_pass;
     QuadIndexedPass quad_index_pass;
 
-    MultiRangeBufferCache multi_range_buffers;
-    boost::container::small_vector<MultiRangeSource, 16> multi_range_sources;
-    VkDeviceSize multi_range_total{};
-
     bool limit_dynamic_storage_buffers = false;
     u32 max_dynamic_storage_buffers = (std::numeric_limits<u32>::max)();
 };

src/video_core/renderer_vulkan/vk_multi_range_buffer.cpp

@@ -1,341 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <mutex>
-
-#include "video_core/renderer_vulkan/vk_multi_range_buffer.h"
-#include "video_core/renderer_vulkan/vk_scheduler.h"
-#include "video_core/vulkan_common/vulkan_device.h"
-
-namespace Vulkan {
-
-MultiRangeBufferCache::MultiRangeBufferCache(const Device& device_,
-                                             MemoryAllocator& memory_allocator_,
-                                             Scheduler& scheduler_)
-    : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_} {
-    sparse_usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                   VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-    if (device.IsBufferDeviceAddressSupported()) {
-        sparse_usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
-    }
-    if (!device.IsSparseBindingSupported()) {
-        return;
-    }
-    u32 memory_type_bits = 0;
-    const VkDeviceSize queried = QueryBlockSize(memory_type_bits);
-    if (queried == 0 || memory_type_bits == 0) {
-        return;
-    }
-    block_size = queried;
-    sparse_memory_type_bits = memory_type_bits;
-    use_sparse = true;
-}
-
-MultiRangeBufferCache::~MultiRangeBufferCache() {
-    const VkDevice logical = *device.GetLogical();
-    const auto& dld = device.GetDispatchLoader();
-    for (auto& [key, entry] : entries) {
-        if (entry.sparse_handle != VK_NULL_HANDLE) {
-            dld.vkDestroyBuffer(logical, entry.sparse_handle, nullptr);
-        }
-    }
-    entries.clear();
-    for (const Retired& item : retired) {
-        dld.vkDestroyBuffer(logical, item.handle, nullptr);
-    }
-    retired.clear();
-}
-
-VkDeviceSize MultiRangeBufferCache::QueryBlockSize(u32& memory_type_bits) const {
-    const VkDevice logical = *device.GetLogical();
-    const auto& dld = device.GetDispatchLoader();
-    const VkBufferCreateInfo probe_ci{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = VK_BUFFER_CREATE_SPARSE_BINDING_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
-        .size = DEFAULT_BLOCK_SIZE,
-        .usage = sparse_usage,
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = nullptr,
-    };
-    VkBuffer probe{};
-    if (dld.vkCreateBuffer(logical, &probe_ci, nullptr, &probe) != VK_SUCCESS) {
-        return 0;
-    }
-    const VkBufferMemoryRequirementsInfo2 reqs_info{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
-        .pNext = nullptr,
-        .buffer = probe,
-    };
-    VkMemoryRequirements2 reqs2{
-        .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
-        .pNext = nullptr,
-        .memoryRequirements = {},
-    };
-    dld.vkGetBufferMemoryRequirements2(logical, &reqs_info, &reqs2);
-    dld.vkDestroyBuffer(logical, probe, nullptr);
-    memory_type_bits = reqs2.memoryRequirements.memoryTypeBits;
-    return reqs2.memoryRequirements.alignment;
-}
-
-u64 MultiRangeBufferCache::HashSources(std::span<const MultiRangeSource> sources) const {
-    u64 hash = 0xcbf29ce484222325ULL;
-    const auto mix = [&hash](u64 value) {
-        hash ^= value;
-        hash *= 0x100000001b3ULL;
-    };
-    for (const MultiRangeSource& source : sources) {
-        mix(reinterpret_cast<u64>(source.handle));
-        mix(static_cast<u64>(source.offset));
-        mix(static_cast<u64>(source.size));
-    }
-    return hash;
-}
-
-bool MultiRangeBufferCache::CanBindSparse(std::span<const MultiRangeSource> sources) const {
-    if (!UsesSparse()) {
-        return false;
-    }
-    for (const MultiRangeSource& source : sources) {
-        if (source.memory == VK_NULL_HANDLE) {
-            return false;
-        }
-        if (source.memory_type >= 32) {
-            return false;
-        }
-        if (((sparse_memory_type_bits >> source.memory_type) & 1) == 0) {
-            return false;
-        }
-        const VkDeviceSize memory_offset = source.memory_offset + source.offset;
-        if ((memory_offset % block_size) != 0) {
-            return false;
-        }
-        if ((source.size % block_size) != 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
-VkBuffer MultiRangeBufferCache::CreateSparse(std::span<const MultiRangeSource> sources,
-                                             VkDeviceSize total) {
-    const VkDevice logical = *device.GetLogical();
-    const auto& dld = device.GetDispatchLoader();
-    const VkBufferCreateInfo buffer_ci{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = VK_BUFFER_CREATE_SPARSE_BINDING_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
-        .size = total,
-        .usage = sparse_usage,
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = nullptr,
-    };
-    VkBuffer handle{};
-    if (dld.vkCreateBuffer(logical, &buffer_ci, nullptr, &handle) != VK_SUCCESS) {
-        return VK_NULL_HANDLE;
-    }
-    std::vector<VkSparseMemoryBind> binds;
-    binds.reserve(sources.size());
-    VkDeviceSize resource_offset = 0;
-    for (const MultiRangeSource& source : sources) {
-        binds.push_back(VkSparseMemoryBind{
-            .resourceOffset = resource_offset,
-            .size = source.size,
-            .memory = source.memory,
-            .memoryOffset = source.memory_offset + source.offset,
-            .flags = 0,
-        });
-        resource_offset += source.size;
-    }
-    const VkSparseBufferMemoryBindInfo buffer_bind{
-        .buffer = handle,
-        .bindCount = static_cast<u32>(binds.size()),
-        .pBinds = binds.data(),
-    };
-    const VkBindSparseInfo bind_info{
-        .sType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
-        .pNext = nullptr,
-        .waitSemaphoreCount = 0,
-        .pWaitSemaphores = nullptr,
-        .bufferBindCount = 1,
-        .pBufferBinds = &buffer_bind,
-        .imageOpaqueBindCount = 0,
-        .pImageOpaqueBinds = nullptr,
-        .imageBindCount = 0,
-        .pImageBinds = nullptr,
-        .signalSemaphoreCount = 0,
-        .pSignalSemaphores = nullptr,
-    };
-    const VkFenceCreateInfo fence_ci{
-        .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-    };
-    vk::Fence fence = device.GetLogical().CreateFence(fence_ci);
-    VkResult bind_result = VK_ERROR_UNKNOWN;
-    {
-        std::scoped_lock lock{scheduler.submit_mutex};
-        bind_result = device.GetGraphicsQueue().BindSparse(bind_info, *fence);
-    }
-    if (bind_result != VK_SUCCESS) {
-        dld.vkDestroyBuffer(logical, handle, nullptr);
-        return VK_NULL_HANDLE;
-    }
-    fence.Wait();
-    return handle;
-}
-
-void MultiRangeBufferCache::DestroySparse(VkBuffer handle) {
-    if (handle == VK_NULL_HANDLE) {
-        return;
-    }
-    retired.push_back(Retired{
-        .handle = handle,
-        .tick = scheduler.CurrentTick(),
-    });
-}
-
-void MultiRangeBufferCache::DrainRetired() {
-    const VkDevice logical = *device.GetLogical();
-    const auto& dld = device.GetDispatchLoader();
-    size_t index = 0;
-    while (index < retired.size()) {
-        if (scheduler.IsFree(retired[index].tick)) {
-            dld.vkDestroyBuffer(logical, retired[index].handle, nullptr);
-            retired[index] = retired.back();
-            retired.pop_back();
-        } else {
-            ++index;
-        }
-    }
-}
-
-MultiRangeRef MultiRangeBufferCache::Get(u64 key, std::span<const MultiRangeSource> sources,
-                                         VkDeviceSize total) {
-    if (sources.empty() || total == 0) {
-        return MultiRangeRef{};
-    }
-    if (!retired.empty()) {
-        DrainRetired();
-    }
-    const u64 geometry = HashSources(sources);
-    const auto it = entries.find(key);
-    if (it != entries.end() && it->second.geometry == geometry && it->second.size == total) {
-        Entry& entry = it->second;
-        MultiRangeRef ref{
-            .handle = entry.sparse_handle,
-            .address = entry.address,
-            .size = entry.size,
-            .needs_gather = false,
-        };
-        if (entry.sparse_handle == VK_NULL_HANDLE) {
-            ref.handle = *entry.gathered;
-            ref.needs_gather = entry.dirty;
-        }
-        return ref;
-    }
-    if (it != entries.end()) {
-        DestroySparse(it->second.sparse_handle);
-        entries.erase(it);
-    }
-
-    Entry entry;
-    entry.geometry = geometry;
-    entry.size = total;
-    if (CanBindSparse(sources)) {
-        entry.sparse_handle = CreateSparse(sources, total);
-        if (entry.sparse_handle != VK_NULL_HANDLE) {
-            entry.owners.reserve(sources.size());
-            for (const MultiRangeSource& source : sources) {
-                entry.owners.push_back(source.handle);
-            }
-        }
-    }
-    if (entry.sparse_handle == VK_NULL_HANDLE) {
-        VkBufferUsageFlags flags = VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
-                                   VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                                   VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-        if (device.IsBufferDeviceAddressSupported()) {
-            flags |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
-        }
-        const VkBufferCreateInfo gather_ci{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0,
-            .size = total,
-            .usage = flags,
-            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-            .queueFamilyIndexCount = 0,
-            .pQueueFamilyIndices = nullptr,
-        };
-        entry.gathered = memory_allocator.CreateBuffer(gather_ci, MemoryUsage::DeviceLocal);
-        entry.dirty = true;
-    }
-    if (device.IsBufferDeviceAddressSupported()) {
-        VkBuffer address_handle = entry.sparse_handle;
-        if (address_handle == VK_NULL_HANDLE) {
-            address_handle = *entry.gathered;
-        }
-        entry.address = device.GetLogical().GetBufferDeviceAddress(address_handle);
-    }
-
-    MultiRangeRef ref{
-        .handle = entry.sparse_handle,
-        .address = entry.address,
-        .size = entry.size,
-        .needs_gather = false,
-    };
-    if (entry.sparse_handle == VK_NULL_HANDLE) {
-        ref.handle = *entry.gathered;
-        ref.needs_gather = true;
-    }
-    entries.emplace(key, std::move(entry));
-    return ref;
-}
-
-void MultiRangeBufferCache::MarkGathered(u64 key) {
-    const auto it = entries.find(key);
-    if (it != entries.end()) {
-        it->second.dirty = false;
-    }
-}
-
-void MultiRangeBufferCache::DropOwner(VkBuffer owner) {
-    if (owner == VK_NULL_HANDLE) {
-        return;
-    }
-    for (auto it = entries.begin(); it != entries.end();) {
-        Entry& entry = it->second;
-        bool owned = false;
-        for (const VkBuffer handle : entry.owners) {
-            if (handle == owner) {
-                owned = true;
-                break;
-            }
-        }
-        if (owned) {
-            DestroySparse(entry.sparse_handle);
-            it = entries.erase(it);
-        } else {
-            ++it;
-        }
-    }
-}
-
-void MultiRangeBufferCache::Invalidate(u64 key) {
-    const auto it = entries.find(key);
-    if (it != entries.end()) {
-        it->second.dirty = true;
-    }
-}
-
-void MultiRangeBufferCache::Clear() {
-    for (auto& [key, entry] : entries) {
-        DestroySparse(entry.sparse_handle);
-    }
-    entries.clear();
-}
-
-} // namespace Vulkan

src/video_core/renderer_vulkan/vk_multi_range_buffer.h

@@ -1,105 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <span>
-#include <unordered_map>
-#include <vector>
-
-#include "common/common_types.h"
-#include "video_core/vulkan_common/vulkan_memory_allocator.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-
-namespace Vulkan {
-
-class Device;
-class Scheduler;
-
-struct MultiRangeSource {
-    VkBuffer handle{};
-    VkDeviceMemory memory{};
-    VkDeviceSize memory_offset{};
-    VkDeviceSize offset{};
-    VkDeviceSize size{};
-    u32 memory_type{};
-};
-
-struct MultiRangeRef {
-    VkBuffer handle{};
-    VkDeviceAddress address{};
-    VkDeviceSize size{};
-    bool needs_gather{};
-};
-
-class MultiRangeBufferCache final {
-public:
-    static constexpr VkDeviceSize DEFAULT_BLOCK_SIZE = 64 * 1024;
-
-    explicit MultiRangeBufferCache(const Device& device_, MemoryAllocator& memory_allocator_,
-                                   Scheduler& scheduler_);
-    ~MultiRangeBufferCache();
-
-    MultiRangeBufferCache(const MultiRangeBufferCache&) = delete;
-    MultiRangeBufferCache& operator=(const MultiRangeBufferCache&) = delete;
-
-    [[nodiscard]] bool UsesSparse() const noexcept {
-        return use_sparse;
-    }
-
-    [[nodiscard]] VkDeviceSize BlockSize() const noexcept {
-        return block_size;
-    }
-
-    [[nodiscard]] MultiRangeRef Get(u64 key, std::span<const MultiRangeSource> sources,
-                                    VkDeviceSize total);
-
-    void MarkGathered(u64 key);
-
-    void Invalidate(u64 key);
-
-    void DropOwner(VkBuffer owner);
-
-    void Clear();
-
-private:
-    struct Retired {
-        VkBuffer handle{};
-        u64 tick{};
-    };
-
-    struct Entry {
-        vk::Buffer gathered;
-        VkBuffer sparse_handle{};
-        VkDeviceAddress address{};
-        VkDeviceSize size{};
-        u64 geometry{};
-        bool dirty{true};
-        std::vector<VkBuffer> owners;
-    };
-
-    [[nodiscard]] u64 HashSources(std::span<const MultiRangeSource> sources) const;
-
-    [[nodiscard]] bool CanBindSparse(std::span<const MultiRangeSource> sources) const;
-
-    [[nodiscard]] VkBuffer CreateSparse(std::span<const MultiRangeSource> sources,
-                                        VkDeviceSize total);
-
-    [[nodiscard]] VkDeviceSize QueryBlockSize(u32& memory_type_bits) const;
-
-    void DestroySparse(VkBuffer handle);
-
-    void DrainRetired();
-
-    const Device& device;
-    MemoryAllocator& memory_allocator;
-    Scheduler& scheduler;
-    bool use_sparse{};
-    VkDeviceSize block_size{DEFAULT_BLOCK_SIZE};
-    u32 sparse_memory_type_bits{};
-    VkBufferUsageFlags sparse_usage{};
-    std::unordered_map<u64, Entry> entries;
-    std::vector<Retired> retired;
-};
-
-} // namespace Vulkan

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -819,7 +819,6 @@ void RasterizerVulkan::ModifyGPUMemory(size_t as_id, GPUVAddr addr, u64 size) {
         std::scoped_lock lock{texture_cache.mutex};
         texture_cache.UnmapGPUMemory(as_id, addr, size);
     }
-    buffer_cache.UnmapGPUMemory(as_id, addr, size);
 }
 
 void RasterizerVulkan::SignalFence(std::function<void()>&& func) {

src/video_core/vulkan_common/vulkan_device.cpp

@@ -1570,8 +1570,6 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
     }
     if (graphics) {
         graphics_family = *graphics;
-        graphics_family_sparse_binding =
-            (queue_family_properties[*graphics].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) != 0;
     }
     if (present) {
         present_family = *present;

src/video_core/vulkan_common/vulkan_device.h

@@ -317,10 +317,6 @@ public:
         return properties.driver.driverID;
     }
 
-    bool IsSparseBindingSupported() const {
-        return features.features.sparseBinding && graphics_family_sparse_binding;
-    }
-
     /// Returns true for tile-based deferred renderers.
     bool IsTiler() const {
         switch (GetDriverID()) {
@@ -1150,7 +1146,6 @@ private:
     bool owns_static_pipeline_cache{};
     u32 instance_version{};      ///< Vulkan instance version.
     u32 graphics_family{};       ///< Main graphics queue family index.
-    bool graphics_family_sparse_binding{};
     u32 present_family{};        ///< Main present queue family index.
 
     struct Extensions {

src/video_core/vulkan_common/vulkan_memory_allocator.cpp

@@ -280,51 +280,6 @@ vk::Buffer MemoryAllocator::CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsa
                         device.GetDispatchLoader());
 }
 
-vk::Buffer MemoryAllocator::CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage,
-                                         VkDeviceSize min_alignment) const {
-    if (min_alignment <= 1) {
-        return CreateBuffer(ci, usage);
-    }
-    VkMemoryPropertyFlags anv_flags = 0;
-    if (usage == MemoryUsage::Stream &&
-        device.GetDriverID() == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA) {
-        anv_flags = VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
-    }
-    u32 memory_type_bits = valid_memory_types;
-    if (usage == MemoryUsage::Stream) {
-        memory_type_bits = 0u;
-    }
-    const VmaAllocationCreateInfo alloc_ci = {
-        .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage),
-        .usage = MemoryUsageVma(usage),
-        .requiredFlags = 0,
-        .preferredFlags = MemoryUsagePreferredVmaFlags(usage) | anv_flags,
-        .memoryTypeBits = memory_type_bits,
-        .pool = VK_NULL_HANDLE,
-        .pUserData = nullptr,
-        .priority = 0.f,
-    };
-
-    VkBuffer handle{};
-    VmaAllocationInfo alloc_info{};
-    VmaAllocation allocation{};
-    VkMemoryPropertyFlags property_flags{};
-
-    vk::Check(vmaCreateBufferWithAlignment(allocator, &ci, &alloc_ci, min_alignment, &handle,
-                                           &allocation, &alloc_info));
-    vmaGetAllocationMemoryProperties(allocator, allocation, &property_flags);
-
-    u8 *data = reinterpret_cast<u8 *>(alloc_info.pMappedData);
-    std::span<u8> mapped_data{};
-    if (data) {
-        mapped_data = std::span<u8>{data, ci.size};
-    }
-    const bool is_coherent = (property_flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
-
-    return vk::Buffer(handle, *device.GetLogical(), allocator, allocation, mapped_data, is_coherent,
-                      device.GetDispatchLoader());
-}
-
 MemoryCommit MemoryAllocator::Commit(const VkMemoryRequirements &reqs, MemoryUsage usage)
 {
     const auto vma_usage = MemoryUsageVma(usage);

src/video_core/vulkan_common/vulkan_memory_allocator.h

@@ -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: Copyright 2019 yuzu Emulator Project
@@ -107,9 +107,6 @@ namespace Vulkan {
 
         vk::Buffer CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage) const;
 
-        vk::Buffer CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage,
-                                VkDeviceSize min_alignment) const;
-
         /**
          * Commits a memory with the specified requirements.
          *

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -229,7 +229,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkGetPipelineExecutableStatisticsKHR);
     X(vkGetSemaphoreCounterValue);
     X(vkMapMemory);
-    X(vkQueueBindSparse);
     X(vkQueueSubmit);
     X(vkQueueSubmit2);
     X(vkResetFences);
@@ -540,19 +539,6 @@ void Buffer::SetObjectNameEXT(const char* name) const {
     SetObjectName(dld, owner, handle, VK_OBJECT_TYPE_BUFFER, name);
 }
 
-MemoryLocation Buffer::Location() const noexcept {
-    if (!allocation) {
-        return MemoryLocation{};
-    }
-    VmaAllocationInfo info{};
-    vmaGetAllocationInfo(allocator, allocation, &info);
-    return MemoryLocation{
-        .memory = info.deviceMemory,
-        .offset = info.offset,
-        .memory_type = info.memoryType,
-    };
-}
-
 void Buffer::Release() const noexcept {
     if (handle) {
         vmaDestroyBuffer(allocator, handle, allocation);

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -345,7 +345,6 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkGetQueryPoolResults vkGetQueryPoolResults{};
     PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue{};
     PFN_vkMapMemory vkMapMemory{};
-    PFN_vkQueueBindSparse vkQueueBindSparse{};
     PFN_vkQueueSubmit vkQueueSubmit{};
     PFN_vkQueueSubmit2 vkQueueSubmit2{};
     PFN_vkResetFences vkResetFences{};
@@ -741,12 +740,6 @@ private:
     const DeviceDispatch* dld = nullptr;
 };
 
-struct MemoryLocation {
-    VkDeviceMemory memory{};
-    VkDeviceSize offset{};
-    u32 memory_type{};
-};
-
 class Buffer {
 public:
     explicit Buffer(VkBuffer handle_, VkDevice owner_, VmaAllocator allocator_,
@@ -818,8 +811,6 @@ public:
 
     void SetObjectNameEXT(const char* name) const;
 
-    MemoryLocation Location() const noexcept;
-
 private:
     void Release() const noexcept;
 
@@ -852,11 +843,6 @@ public:
         return dld->vkQueueSubmit2(queue, submit_infos.size(), submit_infos.data(), fence);
     }
 
-    VkResult BindSparse(Span<VkBindSparseInfo> bind_infos,
-                        VkFence fence = VK_NULL_HANDLE) const noexcept {
-        return dld->vkQueueBindSparse(queue, bind_infos.size(), bind_infos.data(), fence);
-    }
-
     VkResult Present(const VkPresentInfoKHR& present_info) const noexcept {
         return dld->vkQueuePresentKHR(queue, &present_info);
     }