fix

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

CMakeLists.txt

@@ -147,7 +147,11 @@ if (MSVC OR ANDROID)
     set(EXT_DEFAULT ON)
 endif()
 
-CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ${EXT_DEFAULT} "ENABLE_SDL2;NOT MSVC" OFF)
+if (ENABLE_SDL2)
+    # TODO(crueter): Cleanup, each dep that has a bundled option should allow to choose between bundled, external, system
+    CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" OFF "NOT MSVC" OFF)
+    option(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 build" "${MSVC}")
+endif()
 
 cmake_dependent_option(ENABLE_LIBUSB "Enable the use of LibUSB" ON "NOT ANDROID" OFF)
 
@@ -185,8 +189,6 @@ option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ${EXT_DEFAULT})
 # TODO(crueter): CI this?
 option(YUZU_DOWNLOAD_ANDROID_VVL "Download validation layer binary for android" ON)
 
-# TODO(crueter): Cleanup, each dep that has a bundled option should allow to choose between bundled, external, system
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 build" "${MSVC}" "ENABLE_SDL2" OFF)
 
 CMAKE_DEPENDENT_OPTION(YUZU_ROOM "Enable dedicated room functionality" ON "NOT ANDROID" OFF)
 
@@ -197,6 +199,14 @@ CMAKE_DEPENDENT_OPTION(YUZU_CMD "Compile the eden-cli executable" ON "ENABLE_SDL
 CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)
 
 option(YUZU_ENABLE_LTO "Enable link-time optimization" OFF)
+if(YUZU_ENABLE_LTO)
+    include(CheckIPOSupported)
+    check_ipo_supported(RESULT COMPILER_SUPPORTS_LTO)
+    if(NOT COMPILER_SUPPORTS_LTO)
+        message(FATAL_ERROR "Your compiler does not support interprocedural optimization (IPO). Re-run CMake with -DYUZU_ENABLE_LTO=OFF.")
+    endif()
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION ${COMPILER_SUPPORTS_LTO})
+endif()
 
 option(YUZU_DOWNLOAD_TIME_ZONE_DATA "Always download time zone binaries" ON)
 
@@ -884,19 +894,25 @@ if (MSVC AND CXX_CLANG)
     link_libraries(llvm-mingw-runtime)
 endif()
 
-if (YUZU_USE_FASTER_LD AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    # We will assume that if the compiler is GCC, it will attempt to use ld.bfd by default.
-    # Try to pick a faster linker.
+if (YUZU_USE_FASTER_LD)
+    # clang should always use lld
     find_program(LLD lld)
-    find_program(MOLD mold)
 
-    if (MOLD AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.1")
-        message(NOTICE "Selecting mold as linker")
-        add_link_options("-fuse-ld=mold")
-    elseif (LLD)
-        message(NOTICE "Selecting lld as linker")
-        add_link_options("-fuse-ld=lld")
+    if (LLD)
+        set(LINKER lld)
     endif()
+
+    # GNU appears to work better with mold
+    # TODO: mold has been slow lately, see if better options exist (search for gold?)
+    if (CXX_GCC)
+        find_program(MOLD mold)
+        if (MOLD AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.1")
+            set(LINKER mold)
+        endif()
+    endif()
+
+    message(NOTICE "Selecting ${LINKER} as linker")
+    add_link_options("-fuse-ld=${LINKER}")
 endif()
 
 # Set runtime library to MD/MDd for all configurations

docs/User.md

@@ -9,3 +9,21 @@ Eden will store configuration in the following directories:
 - **Linux, macOS, FreeBSD, Solaris, OpenBSD**: `$XDG_DATA_HOME`, `$XDG_CACHE_HOME`, `$XDG_CONFIG_HOME`.
 
 If a `user` directory is present in the current working directory, that will override all global configuration directories and the emulator will use that instead.
+
+# Enhancements
+
+## Filters
+
+Various graphical filters exist - each of them aimed at a specific target/image quality preset.
+
+- **Nearest**: Provides no filtering - useful for debugging.
+- **Bilinear**: Provides the hardware default filtering of the Tegra X1.
+- **Bicubic**: Provides a bicubic interpolation using a Catmull-Rom (or hardware-accelerated) implementation.
+- **Zero-Tangent, B-Spline, Mitchell**: Provides bicubic interpolation using the respective matrix weights. They're normally not hardware accelerated unless the device supports the `VK_QCOM_filter_cubic_weights` extension. The matrix weights are those matching [the specification itself](https://registry.khronos.org/vulkan/specs/latest/html/vkspec.html#VkSamplerCubicWeightsCreateInfoQCOM).
+- **Spline-1**: Bicubic interpolation (similar to Mitchell) but with a faster texel fetch method. Generally less blurry than bicubic.
+- **Gaussian**: Whole-area blur, an applied gaussian blur is done to the entire frame.
+- **Lanczos**: An implementation using `a = 3` (49 texel fetches). Provides sharper edges but blurrier artifacts.
+- **ScaleForce**: Experimental texture upscale method, see [ScaleFish](https://github.com/BreadFish64/ScaleFish).
+- **FSR**: Uses AMD FidelityFX Super Resolution to enhance image quality.
+- **Area**: Area interpolation (high kernel count).
+- **MMPX**: Nearest-neighbour filter aimed at providing higher pixel-art quality.

src/CMakeLists.txt

@@ -141,7 +141,7 @@ else()
         -Wno-missing-field-initializers
     )
 
-    if (CXX_CLANG OR CXX_ICC) # Clang or AppleClang
+    if (CXX_CLANG OR CXX_ICC OR CXX_APPLE) # Clang, AppleClang, or Intel C++
         if (NOT MSVC)
             add_compile_options(
                 -Werror=shadow-uncaptured-local

src/android/app/build.gradle.kts

@@ -175,12 +175,10 @@ android {
                     "-DYUZU_USE_CPM=ON",
                     "-DCPMUTIL_FORCE_BUNDLED=ON",
                     "-DYUZU_USE_BUNDLED_FFMPEG=ON",
-                    "-DYUZU_ENABLE_LTO=ON",
                     "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
                     "-DBUILD_TESTING=OFF",
                     "-DYUZU_TESTS=OFF",
-                    "-DDYNARMIC_TESTS=OFF",
-                    "-DDYNARMIC_ENABLE_LTO=ON"
+                    "-DDYNARMIC_TESTS=OFF"
                 )
 
                 abiFilters("arm64-v8a")

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

@@ -251,10 +251,16 @@
         <item>@string/scaling_filter_nearest_neighbor</item>
         <item>@string/scaling_filter_bilinear</item>
         <item>@string/scaling_filter_bicubic</item>
+        <item>@string/scaling_filter_zero_tangent</item>
+        <item>@string/scaling_filter_bspline</item>
+        <item>@string/scaling_filter_mitchell</item>
+        <item>@string/scaling_filter_spline1</item>
         <item>@string/scaling_filter_gaussian</item>
+        <item>@string/scaling_filter_lanczos</item>
         <item>@string/scaling_filter_scale_force</item>
         <item>@string/scaling_filter_fsr</item>
         <item>@string/scaling_filter_area</item>
+        <item>@string/scaling_filter_mmpx</item>
     </string-array>
 
     <integer-array name="rendererScalingFilterValues">
@@ -265,6 +271,12 @@
         <item>4</item>
         <item>5</item>
         <item>6</item>
+        <item>7</item>
+        <item>8</item>
+        <item>9</item>
+        <item>10</item>
+        <item>11</item>
+        <item>12</item>
     </integer-array>
 
     <string-array name="rendererAntiAliasingNames">

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

@@ -992,10 +992,16 @@
     <string name="scaling_filter_nearest_neighbor">Nearest Neighbor</string>
     <string name="scaling_filter_bilinear">Bilinear</string>
     <string name="scaling_filter_bicubic">Bicubic</string>
+    <string name="scaling_filter_spline1">Spline-1</string>
     <string name="scaling_filter_gaussian">Gaussian</string>
+    <string name="scaling_filter_lanczos">Lanczos</string>
     <string name="scaling_filter_scale_force">ScaleForce</string>
     <string name="scaling_filter_fsr">AMD FidelityFX™ Super Resolution</string>
     <string name="scaling_filter_area">Area</string>
+    <string name="scaling_filter_zero_tangent">Zero-Tangent</string>
+    <string name="scaling_filter_bspline">B-Spline</string>
+    <string name="scaling_filter_mitchell">Mitchell</string>
+    <string name="scaling_filter_mmpx">MMPX</string>
 
     <!-- Anti-Aliasing -->
     <string name="anti_aliasing_none">None</string>

src/common/settings_enums.h

@@ -166,7 +166,7 @@ ENUM(ResolutionSetup,
      Res7X,
      Res8X);
 
-ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Spline1, Gaussian, Lanczos, ScaleForce, Fsr, Area, MaxEnum);
+ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, ZeroTangent, BSpline, Mitchell, Spline1, Gaussian, Lanczos, ScaleForce, Fsr, Area, Mmpx, MaxEnum);
 
 ENUM(AntiAliasing, None, Fxaa, Smaa, MaxEnum);
 

src/core/CMakeLists.txt

@@ -1274,8 +1274,4 @@ if (YUZU_USE_PRECOMPILED_HEADERS)
     target_precompile_headers(core PRIVATE precompiled_headers.h)
 endif()
 
-if (YUZU_ENABLE_LTO)
-  set_property(TARGET core PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
-endif()
-
 create_target_directory_groups(core)

src/dynarmic/tests/A32/fuzz_arm.cpp

@@ -24,6 +24,7 @@
 #include "../rand_int.h"
 #include "../unicorn_emu/a32_unicorn.h"
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/common/fp/fpcr.h"
 #include "dynarmic/common/fp/fpsr.h"
 #include "dynarmic/common/llvm_disassemble.h"
@@ -46,7 +47,7 @@ using namespace Dynarmic;
 
 template<typename Fn>
 bool AnyLocationDescriptorForTerminalHas(IR::Terminal terminal, Fn fn) {
-    return Common::VisitVariant<bool>(terminal, [&](auto t) -> bool {
+    return boost::apply_visitor([&](auto t) -> bool {
         using T = std::decay_t<decltype(t)>;
         if constexpr (std::is_same_v<T, IR::Term::Invalid>) {
             return false;
@@ -72,7 +73,7 @@ bool AnyLocationDescriptorForTerminalHas(IR::Terminal terminal, Fn fn) {
             ASSERT_MSG(false, "Invalid terminal type");
             return false;
         }
-    });
+    }, terminal);
 }
 
 bool ShouldTestInst(u32 instruction, u32 pc, bool is_thumb, bool is_last_inst, A32::ITState it_state = {}) {

src/dynarmic/tests/A32/fuzz_thumb.cpp

@@ -22,6 +22,7 @@
 #include "../rand_int.h"
 #include "../unicorn_emu/a32_unicorn.h"
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/frontend/A32/FPSCR.h"
 #include "dynarmic/frontend/A32/PSR.h"
 #include "dynarmic/frontend/A32/a32_location_descriptor.h"

src/dynarmic/tests/A32/test_arm_instructions.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 /* This file is part of the dynarmic project.
  * Copyright (c) 2016 MerryMage
  * SPDX-License-Identifier: 0BSD
@@ -6,6 +9,7 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/frontend/A32/a32_location_descriptor.h"
 #include "dynarmic/interface/A32/a32.h"
 

src/dynarmic/tests/A32/test_coprocessor.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 /* This file is part of the dynarmic project.
  * Copyright (c) 2022 MerryMage
  * SPDX-License-Identifier: 0BSD
@@ -8,6 +11,7 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/frontend/A32/a32_location_descriptor.h"
 #include "dynarmic/interface/A32/a32.h"
 #include "dynarmic/interface/A32/coprocessor.h"

src/dynarmic/tests/A32/test_svc.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 /* This file is part of the dynarmic project.
  * Copyright (c) 2022 MerryMage
  * SPDX-License-Identifier: 0BSD
@@ -8,6 +11,7 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include "./testenv.h"
+#include "../native/testenv.h"
 
 using namespace Dynarmic;
 

src/dynarmic/tests/A32/test_thumb_instructions.cpp

@@ -10,6 +10,7 @@
 #include "dynarmic/common/common_types.h"
 
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/interface/A32/a32.h"
 
 static Dynarmic::A32::UserConfig GetUserConfig(ThumbTestEnv* testenv) {

src/dynarmic/tests/A32/testenv.h

@@ -17,7 +17,6 @@
 #include "dynarmic/common/assert.h"
 #include "dynarmic/common/common_types.h"
 #include "dynarmic/interface/A32/a32.h"
-#include "../native/testenv.h"
 
 template<typename InstructionType_, u32 infinite_loop_u32>
 class A32TestEnv : public Dynarmic::A32::UserCallbacks {

src/dynarmic/tests/A64/a64.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 /* This file is part of the dynarmic project.
  * Copyright (c) 2018 MerryMage
  * SPDX-License-Identifier: 0BSD
@@ -7,6 +10,7 @@
 #include <oaknut/oaknut.hpp>
 
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/common/fp/fpsr.h"
 #include "dynarmic/interface/exclusive_monitor.h"
 

src/dynarmic/tests/A64/fp_min_max.cpp

@@ -12,6 +12,7 @@
 #include "dynarmic/common/common_types.h"
 
 #include "./testenv.h"
+#include "../native/testenv.h"
 
 using namespace Dynarmic;
 

src/dynarmic/tests/A64/fuzz_with_unicorn.cpp

@@ -19,6 +19,7 @@
 #include "../rand_int.h"
 #include "../unicorn_emu/a64_unicorn.h"
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/common/fp/fpcr.h"
 #include "dynarmic/common/fp/fpsr.h"
 #include "dynarmic/common/llvm_disassemble.h"

src/dynarmic/tests/A64/misaligned_page_table.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 /* This file is part of the dynarmic project.
  * Copyright (c) 2018 MerryMage
  * SPDX-License-Identifier: 0BSD
@@ -6,6 +9,7 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/interface/A64/a64.h"
 
 TEST_CASE("misaligned load/store do not use page_table when detect_misaligned_access_via_page_table is set", "[a64]") {

src/dynarmic/tests/A64/real_world.cpp

@@ -5,6 +5,7 @@
 #include <oaknut/oaknut.hpp>
 
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/interface/A64/a64.h"
 
 using namespace Dynarmic;

src/dynarmic/tests/A64/test_invalidation.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 /* This file is part of the dynarmic project.
  * Copyright (c) 2018 MerryMage
  * SPDX-License-Identifier: 0BSD
@@ -6,6 +9,7 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include "./testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/interface/A64/a64.h"
 
 using namespace Dynarmic;

src/dynarmic/tests/A64/testenv.h

@@ -12,7 +12,6 @@
 #include "dynarmic/common/assert.h"
 #include "dynarmic/common/common_types.h"
 #include "dynarmic/interface/A64/a64.h"
-#include "../native/testenv.h"
 
 using Vector = Dynarmic::A64::Vector;
 

src/dynarmic/tests/decoder_tests.cpp

@@ -36,22 +36,12 @@ TEST_CASE("ASIMD Decoder: Ensure table order correctness", "[decode][a32][.]") {
 
     const auto is_decode_error = [&get_ir](const A32::ASIMDMatcher<A32::TranslatorVisitor>& matcher, u32 instruction) {
         const auto block = get_ir(matcher, instruction);
-
-        for (const auto& ir_inst : block) {
-            if (ir_inst.GetOpcode() == IR::Opcode::A32ExceptionRaised) {
-                if (static_cast<A32::Exception>(ir_inst.GetArg(1).GetU64()) == A32::Exception::DecodeError) {
-                    return true;
-                }
-            }
-        }
-        return false;
+        return std::find_if(block.cbegin(), block.cend(), [](auto const& e) {
+            return e.GetOpcode() == IR::Opcode::A32ExceptionRaised && A32::Exception(e.GetArg(1).GetU64()) == A32::Exception::DecodeError;
+        }) != block.cend();
     };
 
     for (auto iter = table.cbegin(); iter != table.cend(); ++iter) {
-        if (std::strncmp(iter->GetName(), "UNALLOCATED", 11) == 0) {
-            continue;
-        }
-
         const u32 expect = iter->GetExpected();
         const u32 mask = iter->GetMask();
         u32 x = 0;
@@ -59,15 +49,17 @@ TEST_CASE("ASIMD Decoder: Ensure table order correctness", "[decode][a32][.]") {
             const u32 instruction = expect | x;
 
             const bool iserr = is_decode_error(*iter, instruction);
-            const auto alternative = std::find_if(table.cbegin(), iter, [instruction](const auto& m) { return m.Matches(instruction); });
+            const auto alternative = std::find_if(table.cbegin(), iter, [instruction](const auto& m) {
+                return m.Matches(instruction);
+            });
             const bool altiserr = is_decode_error(*alternative, instruction);
 
             INFO("Instruction: " << std::hex << std::setfill('0') << std::setw(8) << instruction);
             INFO("Expect:      " << std::hex << std::setfill('0') << std::setw(8) << expect);
             INFO("Fill:        " << std::hex << std::setfill('0') << std::setw(8) << x);
-            INFO("Name:        " << iter->GetName());
+            //INFO("Name:        " << *A32::GetNameASIMD<A32::TranslatorVisitor>(instruction));
             INFO("iserr:       " << iserr);
-            INFO("alternative: " << alternative->GetName());
+            //INFO("alternative: " << alternative->GetName());
             INFO("altiserr:    " << altiserr);
 
             REQUIRE(((!iserr && alternative == iter) || (iserr && alternative != iter && !altiserr)));
@@ -75,4 +67,4 @@ TEST_CASE("ASIMD Decoder: Ensure table order correctness", "[decode][a32][.]") {
             x = ((x | mask) + 1) & ~mask;
         } while (x != 0);
     }
-}
+}

src/dynarmic/tests/native/preserve_xmm.cpp

@@ -6,6 +6,7 @@
 #include <immintrin.h>
 
 #include "../A64/testenv.h"
+#include "../native/testenv.h"
 #include "dynarmic/common/fp/fpsr.h"
 #include "dynarmic/interface/exclusive_monitor.h"
 

src/dynarmic/tests/print_info.cpp

@@ -32,27 +32,26 @@
 #include "dynarmic/frontend/A64/translate/a64_translate.h"
 #include "dynarmic/frontend/A64/translate/impl/impl.h"
 #include "dynarmic/interface/A32/a32.h"
+#include "dynarmic/interface/A32/config.h"
 #include "dynarmic/interface/A32/disassembler.h"
 #include "dynarmic/ir/basic_block.h"
 #include "dynarmic/ir/opt_passes.h"
 
 using namespace Dynarmic;
 
-const char* GetNameOfA32Instruction(u32 instruction) {
-    if (auto vfp_decoder = A32::DecodeVFP<A32::TranslatorVisitor>(instruction)) {
-        return vfp_decoder->get().GetName();
-    } else if (auto asimd_decoder = A32::DecodeASIMD<A32::TranslatorVisitor>(instruction)) {
-        return asimd_decoder->get().GetName();
-    } else if (auto decoder = A32::DecodeArm<A32::TranslatorVisitor>(instruction)) {
-        return decoder->get().GetName();
-    }
+std::string_view GetNameOfA32Instruction(u32 instruction) {
+    //if (auto const vfp_decoder = A32::DecodeVFP<A32::TranslatorVisitor>(instruction))
+    //    return *A32::GetNameVFP<A32::TranslatorVisitor>(instruction);
+    //else if (auto const asimd_decoder = A32::DecodeASIMD<A32::TranslatorVisitor>(instruction))
+    //    return *A32::GetNameASIMD<A32::TranslatorVisitor>(instruction);
+    //else if (auto const decoder = A32::DecodeArm<A32::TranslatorVisitor>(instruction))
+    //    return *A32::GetNameARM<A32::TranslatorVisitor>(instruction);
     return "<null>";
 }
 
-const char* GetNameOfA64Instruction(u32 instruction) {
-    if (auto decoder = A64::Decode<A64::TranslatorVisitor>(instruction)) {
-        return decoder->get().GetName();
-    }
+std::string_view GetNameOfA64Instruction(u32 instruction) {
+    //if (auto const decoder = A64::Decode<A64::TranslatorVisitor>(instruction))
+    //    return *A64::GetName<A64::TranslatorVisitor>(instruction);
     return "<null>";
 }
 
@@ -66,7 +65,7 @@ void PrintA32Instruction(u32 instruction) {
     fmt::print("should_continue: {}\n\n", should_continue);
     fmt::print("IR:\n");
     fmt::print("{}\n", IR::DumpBlock(ir_block));
-    Optimization::Optimize(ir_block, conf, {});
+    Optimization::Optimize(ir_block, A32::UserConfig{}, {});
     fmt::print("Optimized IR:\n");
     fmt::print("{}\n", IR::DumpBlock(ir_block));
 }
@@ -81,7 +80,7 @@ void PrintA64Instruction(u32 instruction) {
     fmt::print("should_continue: {}\n\n", should_continue);
     fmt::print("IR:\n");
     fmt::print("{}\n", IR::DumpBlock(ir_block));
-    Optimization::Optimize(ir_block, conf, {});
+    Optimization::Optimize(ir_block, A64::UserConfig{}, {});
     fmt::print("Optimized IR:\n");
     fmt::print("{}\n", IR::DumpBlock(ir_block));
 }
@@ -99,7 +98,7 @@ void PrintThumbInstruction(u32 instruction) {
     fmt::print("should_continue: {}\n\n", should_continue);
     fmt::print("IR:\n");
     fmt::print("{}\n", IR::DumpBlock(ir_block));
-    Optimization::Optimize(ir_block, conf, {});
+    Optimization::Optimize(ir_block, A32::UserConfig{}, {});
     fmt::print("Optimized IR:\n");
     fmt::print("{}\n", IR::DumpBlock(ir_block));
 }

src/qt_common/shared_translation.cpp

@@ -570,12 +570,16 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent)
                               PAIR(ScalingFilter, NearestNeighbor, tr("Nearest Neighbor")),
                               PAIR(ScalingFilter, Bilinear, tr("Bilinear")),
                               PAIR(ScalingFilter, Bicubic, tr("Bicubic")),
+                              PAIR(ScalingFilter, ZeroTangent, tr("Zero-Tangent")),
+                              PAIR(ScalingFilter, BSpline, tr("B-Spline")),
+                              PAIR(ScalingFilter, Mitchell, tr("Mitchell")),
                               PAIR(ScalingFilter, Spline1, tr("Spline-1")),
                               PAIR(ScalingFilter, Gaussian, tr("Gaussian")),
                               PAIR(ScalingFilter, Lanczos, tr("Lanczos")),
                               PAIR(ScalingFilter, ScaleForce, tr("ScaleForce")),
                               PAIR(ScalingFilter, Fsr, tr("AMD FidelityFX™️ Super Resolution")),
                               PAIR(ScalingFilter, Area, tr("Area")),
+                              PAIR(ScalingFilter, Mmpx, tr("MMPX")),
                           }});
     translations->insert({Settings::EnumMetadata<Settings::AntiAliasing>::Index(),
                           {

src/qt_common/shared_translation.h

@@ -38,6 +38,9 @@ static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map
     {Settings::ScalingFilter::Bilinear,
      QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bilinear"))},
     {Settings::ScalingFilter::Bicubic, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bicubic"))},
+    {Settings::ScalingFilter::ZeroTangent, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Zero-Tangent"))},
+    {Settings::ScalingFilter::BSpline, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "B-Spline"))},
+    {Settings::ScalingFilter::Mitchell, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Mitchell"))},
      {Settings::ScalingFilter::Spline1,
      QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Spline-1"))},
     {Settings::ScalingFilter::Gaussian,
@@ -48,6 +51,7 @@ static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map
      QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "ScaleForce"))},
     {Settings::ScalingFilter::Fsr, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FSR"))},
     {Settings::ScalingFilter::Area, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Area"))},
+    {Settings::ScalingFilter::Mmpx, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "MMPX"))},
 };
 
 static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map = {

src/video_core/CMakeLists.txt

@@ -399,10 +399,6 @@ if (YUZU_USE_PRECOMPILED_HEADERS)
     target_precompile_headers(video_core PRIVATE precompiled_headers.h)
 endif()
 
-if (YUZU_ENABLE_LTO)
-  set_property(TARGET video_core PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
-endif()
-
 if (ANDROID AND ARCHITECTURE_arm64)
     target_link_libraries(video_core PRIVATE adrenotools)
 endif()

src/video_core/buffer_cache/buffer_cache.h

@@ -785,18 +785,13 @@ void BufferCache<P>::BindHostGraphicsUniformBuffers(size_t stage) {
 }
 
 template <class P>
-void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32 binding_index,
-                                                   bool needs_bind) {
+void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32 binding_index, bool needs_bind) {
+    ++channel_state->uniform_cache_shots[0];
     const Binding& binding = channel_state->uniform_buffers[stage][index];
     const DAddr device_addr = binding.device_addr;
     const u32 size = (std::min)(binding.size, (*channel_state->uniform_buffer_sizes)[stage][index]);
     Buffer& buffer = slot_buffers[binding.buffer_id];
     TouchBuffer(buffer, binding.buffer_id);
-    const bool sync_buffer = SynchronizeBuffer(buffer, device_addr, size);
-    if (sync_buffer) {
-        ++channel_state->uniform_cache_hits[0];
-    }
-    ++channel_state->uniform_cache_shots[0];
     const bool use_fast_buffer = binding.buffer_id != NULL_BUFFER_ID &&
                                  size <= channel_state->uniform_buffer_skip_cache_size &&
                                  !memory_tracker.IsRegionGpuModified(device_addr, size);
@@ -827,7 +822,10 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
         device_memory.ReadBlockUnsafe(device_addr, span.data(), size);
         return;
     }
-
+    // Classic cached path
+    if (SynchronizeBuffer(buffer, device_addr, size)) {
+        ++channel_state->uniform_cache_hits[0];
+    }
     // Skip binding if it's not needed and if the bound buffer is not the fast version
     // This exists to avoid instances where the fast buffer is bound and a GPU write happens
     needs_bind |= HasFastUniformBufferBound(stage, binding_index);

src/video_core/host_shaders/CMakeLists.txt

@@ -44,9 +44,13 @@ set(SHADER_FILES
     pitch_unswizzle.comp
     present_area.frag
     present_bicubic.frag
+    present_zero_tangent.frag
+    present_bspline.frag
+    present_mitchell.frag
     present_gaussian.frag
     present_lanczos.frag
     present_spline1.frag
+    present_mmpx.frag
     queries_prefix_scan_sum.comp
     queries_prefix_scan_sum_nosubgroups.comp
     resolve_conditional_render.comp

src/video_core/host_shaders/present_bicubic.frag

@@ -1,56 +1,37 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
-
 #version 460 core
-
-
 layout (location = 0) in vec2 frag_tex_coord;
-
 layout (location = 0) out vec4 color;
-
 layout (binding = 0) uniform sampler2D color_texture;
-
-vec4 cubic(float v) {
-    vec4 n = vec4(1.0, 2.0, 3.0, 4.0) - v;
-    vec4 s = n * n * n;
-    float x = s.x;
-    float y = s.y - 4.0 * s.x;
-    float z = s.z - 4.0 * s.y + 6.0 * s.x;
-    float w = 6.0 - x - y - z;
-    return vec4(x, y, z, w) * (1.0 / 6.0);
+vec4 cubic(float x) {
+    float x2 = x * x;
+    float x3 = x2 * x;
+    return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+         0.0,   2.0,  0.0,  0.0,
+        -1.0,   0.0,  1.0,  0.0,
+         2.0,  -5.0,  4.0, -1.0,
+        -1.0,   3.0, -3.0,  1.0
+    ) * (1.0 / 2.0));
 }
-
-vec4 textureBicubic( sampler2D textureSampler, vec2 texCoords ) {
-
-    vec2 texSize = textureSize(textureSampler, 0);
-    vec2 invTexSize = 1.0 / texSize;
-
-    texCoords = texCoords * texSize - 0.5;
-
-    vec2 fxy = fract(texCoords);
-    texCoords -= fxy;
-
-    vec4 xcubic = cubic(fxy.x);
-    vec4 ycubic = cubic(fxy.y);
-
-    vec4 c = texCoords.xxyy + vec2(-0.5, +1.5).xyxy;
-
-    vec4 s = vec4(xcubic.xz + xcubic.yw, ycubic.xz + ycubic.yw);
-    vec4 offset = c + vec4(xcubic.yw, ycubic.yw) / s;
-
-    offset *= invTexSize.xxyy;
-
-    vec4 sample0 = texture(textureSampler, offset.xz);
-    vec4 sample1 = texture(textureSampler, offset.yz);
-    vec4 sample2 = texture(textureSampler, offset.xw);
-    vec4 sample3 = texture(textureSampler, offset.yw);
-
-    float sx = s.x / (s.x + s.y);
-    float sy = s.z / (s.z + s.w);
-
-    return mix(mix(sample3, sample2, sx), mix(sample1, sample0, sx), sy);
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+    vec2 tex_size = vec2(textureSize(samp, 0));
+    vec2 cc_tex = uv * tex_size - 0.5f;
+    vec2 fex = cc_tex - floor(cc_tex);
+    vec4 xcubic = cubic(fex.x);
+    vec4 ycubic = cubic(fex.y);
+    vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+    vec4 z = vec4(xcubic.yw, ycubic.yw);
+    vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+    vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+    vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+    return mix(
+        mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+        mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+    n.y);
 }
-
 void main() {
     color = textureBicubic(color_texture, frag_tex_coord);
 }

src/video_core/host_shaders/present_bspline.frag

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#version 460 core
+layout (location = 0) in vec2 frag_tex_coord;
+layout (location = 0) out vec4 color;
+layout (binding = 0) uniform sampler2D color_texture;
+vec4 cubic(float x) {
+    float x2 = x * x;
+    float x3 = x2 * x;
+    return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+         1.0,   4.0,  1.0,  0.0,
+        -3.0,   0.0,  3.0,  0.0,
+         3.0,  -6.0,  3.0,  0.0,
+        -1.0,   3.0, -3.0,  1.0
+    ) * (1.0 / 6.0));
+}
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+    vec2 tex_size = vec2(textureSize(samp, 0));
+    vec2 cc_tex = uv * tex_size - 0.5f;
+    vec2 fex = cc_tex - floor(cc_tex);
+    vec4 xcubic = cubic(fex.x);
+    vec4 ycubic = cubic(fex.y);
+    vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+    vec4 z = vec4(xcubic.yw, ycubic.yw);
+    vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+    vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+    vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+    return mix(
+        mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+        mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+    n.y);
+}
+void main() {
+    color = textureBicubic(color_texture, frag_tex_coord);
+}

src/video_core/host_shaders/present_mitchell.frag

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#version 460 core
+layout (location = 0) in vec2 frag_tex_coord;
+layout (location = 0) out vec4 color;
+layout (binding = 0) uniform sampler2D color_texture;
+vec4 cubic(float x) {
+    float x2 = x * x;
+    float x3 = x2 * x;
+    return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+         1.0,  16.0,   1.0,  0.0,
+        -9.0,   0.0,   9.0,  0.0,
+        15.0, -36.0,  27.0, -6.0,
+        -7.0,  21.0, -21.0,  7.0
+    ) * (1.0 / 18.0));
+}
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+    vec2 tex_size = vec2(textureSize(samp, 0));
+    vec2 cc_tex = uv * tex_size - 0.5f;
+    vec2 fex = cc_tex - floor(cc_tex);
+    vec4 xcubic = cubic(fex.x);
+    vec4 ycubic = cubic(fex.y);
+    vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+    vec4 z = vec4(xcubic.yw, ycubic.yw);
+    vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+    vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+    vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+    return mix(
+        mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+        mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+    n.y);
+}
+void main() {
+    color = textureBicubic(color_texture, frag_tex_coord);
+}

src/video_core/host_shaders/present_mmpx.frag

@@ -0,0 +1,131 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright 2023 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#version 460 core
+layout(location = 0) in vec2 tex_coord;
+layout(location = 0) out vec4 frag_color;
+layout(binding = 0) uniform sampler2D tex;
+
+#define src(x, y) texture(tex, coord + vec2(x, y) * 1.0 / source_size)
+
+float luma(vec4 col) {
+    return dot(col.rgb, vec3(0.2126, 0.7152, 0.0722)) * (1.0 - col.a);
+}
+
+bool same(vec4 B, vec4 A0) {
+    return all(equal(B, A0));
+}
+
+bool notsame(vec4 B, vec4 A0) {
+    return any(notEqual(B, A0));
+}
+
+bool all_eq2(vec4 B, vec4 A0, vec4 A1) {
+    return (same(B,A0) && same(B,A1));
+}
+
+bool all_eq3(vec4 B, vec4 A0, vec4 A1, vec4 A2) {
+    return (same(B,A0) && same(B,A1) && same(B,A2));
+}
+
+bool all_eq4(vec4 B, vec4 A0, vec4 A1, vec4 A2, vec4 A3) {
+    return (same(B,A0) && same(B,A1) && same(B,A2) && same(B,A3));
+}
+
+bool any_eq3(vec4 B, vec4 A0, vec4 A1, vec4 A2) {
+    return (same(B,A0) || same(B,A1) || same(B,A2));
+}
+
+bool none_eq2(vec4 B, vec4 A0, vec4 A1) {
+    return (notsame(B,A0) && notsame(B,A1));
+}
+
+bool none_eq4(vec4 B, vec4 A0, vec4 A1, vec4 A2, vec4 A3) {
+    return (notsame(B,A0) && notsame(B,A1) && notsame(B,A2) && notsame(B,A3));
+}
+
+void main()
+{
+    vec2 source_size = vec2(textureSize(tex, 0));
+    vec2 pos = fract(tex_coord * source_size) - vec2(0.5, 0.5);
+    vec2 coord = tex_coord - pos / source_size;
+
+    vec4 E = src(0.0,0.0);
+
+    vec4 A = src(-1.0,-1.0);
+    vec4 B = src(0.0,-1.0);
+    vec4 C = src(1.0,-1.0);
+
+    vec4 D = src(-1.0,0.0);
+    vec4 F = src(1.0,0.0);
+
+    vec4 G = src(-1.0,1.0);
+    vec4 H = src(0.0,1.0);
+    vec4 I = src(1.0,1.0);
+
+    vec4 J = E;
+    vec4 K = E;
+    vec4 L = E;
+    vec4 M = E;
+
+    frag_color = E;
+
+    if(same(E,A) && same(E,B) && same(E,C) && same(E,D) && same(E,F) && same(E,G) && same(E,H) && same(E,I)) return;
+
+    vec4 P  = src(0.0,2.0);
+    vec4 Q  = src(-2.0,0.0);
+    vec4 R  = src(2.0,0.0);
+    vec4 S  = src(0.0,2.0);
+
+    float Bl = luma(B);
+    float Dl = luma(D);
+    float El = luma(E);
+    float Fl = luma(F);
+    float Hl = luma(H);
+
+    if (((same(D,B) && notsame(D,H) && notsame(D,F))) && ((El>=Dl) || same(E,A)) && any_eq3(E,A,C,G) && ((El<Dl) || notsame(A,D) || notsame(E,P) || notsame(E,Q))) J=mix(D, J, 0.5);
+    if (((same(B,F) && notsame(B,D) && notsame(B,H))) && ((El>=Bl) || same(E,C)) && any_eq3(E,A,C,I) && ((El<Bl) || notsame(C,B) || notsame(E,P) || notsame(E,R))) K=mix(B, K, 0.5);
+    if (((same(H,D) && notsame(H,F) && notsame(H,B))) && ((El>=Hl) || same(E,G)) && any_eq3(E,A,G,I) && ((El<Hl) || notsame(G,H) || notsame(E,S) || notsame(E,Q))) L=mix(H, L, 0.5);
+    if (((same(F,H) && notsame(F,B) && notsame(F,D))) && ((El>=Fl) || same(E,I)) && any_eq3(E,C,G,I) && ((El<Fl) || notsame(I,H) || notsame(E,R) || notsame(E,S))) M=mix(F, M, 0.5);
+
+    if ((notsame(E,F) && all_eq4(E,C,I,D,Q) && all_eq2(F,B,H)) && notsame(F,src(3.0,0.0))) {M=mix(M, F, 0.5); K=mix(K, M, 0.5);};
+    if ((notsame(E,D) && all_eq4(E,A,G,F,R) && all_eq2(D,B,H)) && notsame(D,src(-3.0,0.0))) {L=mix(L, D, 0.5); J=mix(J, L, 0.5);};
+    if ((notsame(E,H) && all_eq4(E,G,I,B,P) && all_eq2(H,D,F)) && notsame(H,src(0.0,3.0))) {M=mix(M, H, 0.5); L=mix(L, M, 0.5);};
+    if ((notsame(E,B) && all_eq4(E,A,C,H,S) && all_eq2(B,D,F)) && notsame(B,src(0.0,-3.0))) {K=mix(K, B, 0.5); J=mix(J, K, 0.5);};
+
+    if ((Bl<El) && all_eq4(E,G,H,I,S) && none_eq4(E,A,D,C,F)) {K=mix(K, B, 0.5); J=mix(J, K, 0.5);}
+    if ((Hl<El) && all_eq4(E,A,B,C,P) && none_eq4(E,D,G,I,F)) {M=mix(M, H, 0.5); L=mix(L, M, 0.5);}
+    if ((Fl<El) && all_eq4(E,A,D,G,Q) && none_eq4(E,B,C,I,H)) {M=mix(M, F, 0.5); K=mix(K, M, 0.5);}
+    if ((Dl<El) && all_eq4(E,C,F,I,R) && none_eq4(E,B,A,G,H)) {L=mix(L, D, 0.5); J=mix(J, L, 0.5);}
+
+    if (notsame(H,B)) {
+        if (notsame(H,A) && notsame(H,E) && notsame(H,C)) {
+            if (all_eq3(H,G,F,R) && none_eq2(H,D,src(2.0,-1.0))) L=mix(M, L, 0.5);
+            if (all_eq3(H,I,D,Q) && none_eq2(H,F,src(-2.0,-1.0))) M=mix(L, M, 0.5);
+        }
+
+        if (notsame(B,I) && notsame(B,G) && notsame(B,E)) {
+            if (all_eq3(B,A,F,R) && none_eq2(B,D,src(2.0,1.0))) J=mix(K, L, 0.5);
+            if (all_eq3(B,C,D,Q) && none_eq2(B,F,src(-2.0,1.0))) K=mix(J, K, 0.5);
+        }
+    }
+
+    if (notsame(F,D)) {
+        if (notsame(D,I) && notsame(D,E) && notsame(D,C)) {
+            if (all_eq3(D,A,H,S) && none_eq2(D,B,src(1.0,2.0))) J=mix(L, J, 0.5);
+            if (all_eq3(D,G,B,P) && none_eq2(D,H,src(1.0,2.0))) L=mix(J, L, 0.5);
+        }
+
+        if (notsame(F,E) && notsame(F,A) && notsame(F,G)) {
+            if (all_eq3(F,C,H,S) && none_eq2(F,B,src(-1.0,2.0))) K=mix(M, K, 0.5);
+            if (all_eq3(F,I,B,P) && none_eq2(F,H,src(-1.0,-2.0))) M=mix(K, M, 0.5);
+        }
+    }
+
+    vec2 a = fract(tex_coord * source_size);
+    vec4 colour = (a.x < 0.5) ? (a.y < 0.5 ? J : L) : (a.y < 0.5 ? K : M);
+    frag_color = colour;
+}

src/video_core/host_shaders/present_zero_tangent.frag

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#version 460 core
+layout (location = 0) in vec2 frag_tex_coord;
+layout (location = 0) out vec4 color;
+layout (binding = 0) uniform sampler2D color_texture;
+vec4 cubic(float x) {
+    float x2 = x * x;
+    float x3 = x2 * x;
+    return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+         0.0,   2.0,  0.0,  0.0,
+        -2.0,   0.0,  2.0,  0.0,
+         4.0,  -4.0,  2.0, -2.0,
+        -2.0,   2.0, -2.0,  1.0
+    ) * (1.0 / 2.0));
+}
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+    vec2 tex_size = vec2(textureSize(samp, 0));
+    vec2 cc_tex = uv * tex_size - 0.5f;
+    vec2 fex = cc_tex - floor(cc_tex);
+    vec4 xcubic = cubic(fex.x);
+    vec4 ycubic = cubic(fex.y);
+    vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+    vec4 z = vec4(xcubic.yw, ycubic.yw);
+    vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+    vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+    vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+    return mix(
+        mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+        mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+    n.y);
+}
+void main() {
+    color = textureBicubic(color_texture, frag_tex_coord);
+}

src/video_core/renderer_opengl/gl_blit_screen.cpp

@@ -8,6 +8,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/settings.h"
+#include "common/settings_enums.h"
 #include "video_core/present.h"
 #include "video_core/renderer_opengl/gl_blit_screen.h"
 #include "video_core/renderer_opengl/gl_state_tracker.h"
@@ -86,6 +87,15 @@ void BlitScreen::CreateWindowAdapt() {
     case Settings::ScalingFilter::Bicubic:
         window_adapt = MakeBicubic(device);
         break;
+    case Settings::ScalingFilter::ZeroTangent:
+        window_adapt = MakeZeroTangent(device);
+        break;
+    case Settings::ScalingFilter::BSpline:
+        window_adapt = MakeBSpline(device);
+        break;
+    case Settings::ScalingFilter::Mitchell:
+        window_adapt = MakeMitchell(device);
+        break;
     case Settings::ScalingFilter::Gaussian:
         window_adapt = MakeGaussian(device);
         break;
@@ -101,6 +111,9 @@ void BlitScreen::CreateWindowAdapt() {
     case Settings::ScalingFilter::Area:
         window_adapt = MakeArea(device);
         break;
+    case Settings::ScalingFilter::Mmpx:
+        window_adapt = MakeMmpx(device);
+        break;
     case Settings::ScalingFilter::Fsr:
     case Settings::ScalingFilter::Bilinear:
     default:

src/video_core/renderer_opengl/present/filters.cpp

@@ -14,6 +14,10 @@
 #include "video_core/host_shaders/present_gaussian_frag.h"
 #include "video_core/host_shaders/present_lanczos_frag.h"
 #include "video_core/host_shaders/present_spline1_frag.h"
+#include "video_core/host_shaders/present_mitchell_frag.h"
+#include "video_core/host_shaders/present_bspline_frag.h"
+#include "video_core/host_shaders/present_zero_tangent_frag.h"
+#include "video_core/host_shaders/present_mmpx_frag.h"
 #include "video_core/renderer_opengl/present/filters.h"
 #include "video_core/renderer_opengl/present/util.h"
 
@@ -39,6 +43,21 @@ std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device) {
                                              HostShaders::PRESENT_BICUBIC_FRAG);
 }
 
+std::unique_ptr<WindowAdaptPass> MakeMitchell(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_MITCHELL_FRAG);
+}
+
+std::unique_ptr<WindowAdaptPass> MakeZeroTangent(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_ZERO_TANGENT_FRAG);
+}
+
+std::unique_ptr<WindowAdaptPass> MakeBSpline(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_BSPLINE_FRAG);
+}
+
 std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device) {
     return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
                                              HostShaders::PRESENT_GAUSSIAN_FRAG);
@@ -60,4 +79,9 @@ std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device) {
                                              HostShaders::PRESENT_AREA_FRAG);
 }
 
+std::unique_ptr<WindowAdaptPass> MakeMmpx(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateNearestNeighborSampler(),
+                                             HostShaders::PRESENT_MMPX_FRAG);
+}
+
 } // namespace OpenGL

src/video_core/renderer_opengl/present/filters.h

@@ -17,10 +17,14 @@ namespace OpenGL {
 std::unique_ptr<WindowAdaptPass> MakeNearestNeighbor(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeZeroTangent(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeMitchell(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeBSpline(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeMmpx(const Device& device);
 
 } // namespace OpenGL

src/video_core/renderer_vulkan/present/filters.cpp

@@ -7,6 +7,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <vulkan/vulkan_core.h>
+#include "common/assert.h"
 #include "common/common_types.h"
 
 #include "video_core/host_shaders/present_area_frag_spv.h"
@@ -14,6 +16,10 @@
 #include "video_core/host_shaders/present_gaussian_frag_spv.h"
 #include "video_core/host_shaders/present_lanczos_frag_spv.h"
 #include "video_core/host_shaders/present_spline1_frag_spv.h"
+#include "video_core/host_shaders/present_mitchell_frag_spv.h"
+#include "video_core/host_shaders/present_bspline_frag_spv.h"
+#include "video_core/host_shaders/present_zero_tangent_frag_spv.h"
+#include "video_core/host_shaders/present_mmpx_frag_spv.h"
 #include "video_core/host_shaders/vulkan_present_frag_spv.h"
 #include "video_core/host_shaders/vulkan_present_scaleforce_fp16_frag_spv.h"
 #include "video_core/host_shaders/vulkan_present_scaleforce_fp32_frag_spv.h"
@@ -52,13 +58,28 @@ std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device, VkFormat fram
                                              BuildShader(device, PRESENT_SPLINE1_FRAG_SPV));
 }
 
-std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format) {
+std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format, VkCubicFilterWeightsQCOM qcom_weights) {
     // No need for handrolled shader -- if the VK impl can do it for us ;)
-    if (device.IsExtFilterCubicSupported())
-        return std::make_unique<WindowAdaptPass>(device, frame_format, CreateCubicSampler(device),
-                                                 BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
-    return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
-                                                BuildShader(device, PRESENT_BICUBIC_FRAG_SPV));
+    // Catmull-Rom is default bicubic for all implementations...
+    if (device.IsExtFilterCubicSupported() && (device.IsQcomFilterCubicWeightsSupported() || qcom_weights == VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM)) {
+        return std::make_unique<WindowAdaptPass>(device, frame_format, CreateCubicSampler(device,
+            qcom_weights), BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
+    } else {
+        return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device), [&](){
+            switch (qcom_weights) {
+            case VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM:
+                return BuildShader(device, PRESENT_BICUBIC_FRAG_SPV);
+            case VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM:
+                return BuildShader(device, PRESENT_ZERO_TANGENT_FRAG_SPV);
+            case VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM:
+                return BuildShader(device, PRESENT_BSPLINE_FRAG_SPV);
+            case VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM:
+                return BuildShader(device, PRESENT_MITCHELL_FRAG_SPV);
+            default:
+                UNREACHABLE();
+            }
+        }());
+    }
 }
 
 std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device, VkFormat frame_format) {
@@ -81,4 +102,9 @@ std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device, VkFormat frame_f
                                              BuildShader(device, PRESENT_AREA_FRAG_SPV));
 }
 
+std::unique_ptr<WindowAdaptPass> MakeMmpx(const Device& device, VkFormat frame_format) {
+    return std::make_unique<WindowAdaptPass>(device, frame_format, CreateNearestNeighborSampler(device),
+                                             BuildShader(device, PRESENT_MMPX_FRAG_SPV));
+}
+
 } // namespace Vulkan

src/video_core/renderer_vulkan/present/filters.h

@@ -17,11 +17,12 @@ class MemoryAllocator;
 
 std::unique_ptr<WindowAdaptPass> MakeNearestNeighbor(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device, VkFormat frame_format);
-std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format);
+std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format, VkCubicFilterWeightsQCOM qcom_weights);
 std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device, VkFormat frame_format);
+std::unique_ptr<WindowAdaptPass> MakeMmpx(const Device& device, VkFormat frame_format);
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/present/util.cpp

@@ -624,8 +624,8 @@ vk::Sampler CreateNearestNeighborSampler(const Device& device) {
     return device.GetLogical().CreateSampler(ci_nn);
 }
 
-vk::Sampler CreateCubicSampler(const Device& device) {
-    const VkSamplerCreateInfo ci_nn{
+vk::Sampler CreateCubicSampler(const Device& device, VkCubicFilterWeightsQCOM qcom_weights) {
+    VkSamplerCreateInfo ci_nn{
         .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
         .pNext = nullptr,
         .flags = 0,
@@ -645,7 +645,14 @@ vk::Sampler CreateCubicSampler(const Device& device) {
         .borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
         .unnormalizedCoordinates = VK_FALSE,
     };
-
+    const VkSamplerCubicWeightsCreateInfoQCOM ci_qcom_nn{
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM,
+        .pNext = nullptr,
+        .cubicWeights = qcom_weights
+    };
+    // If not specified, assume Catmull-Rom
+    if (qcom_weights != VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM)
+        ci_nn.pNext = &ci_qcom_nn;
     return device.GetLogical().CreateSampler(ci_nn);
 }
 

src/video_core/renderer_vulkan/present/util.h

@@ -57,7 +57,7 @@ VkWriteDescriptorSet CreateWriteDescriptorSet(std::vector<VkDescriptorImageInfo>
                                               VkDescriptorSet set, u32 binding);
 vk::Sampler CreateBilinearSampler(const Device& device);
 vk::Sampler CreateNearestNeighborSampler(const Device& device);
-vk::Sampler CreateCubicSampler(const Device& device);
+vk::Sampler CreateCubicSampler(const Device& device, VkCubicFilterWeightsQCOM qcom_weights);
 
 void BeginRenderPass(vk::CommandBuffer& cmdbuf, VkRenderPass render_pass, VkFramebuffer framebuffer,
                      VkExtent2D extent);

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -7,6 +7,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <vulkan/vulkan_core.h>
 #include "video_core/framebuffer_config.h"
 #include "video_core/present.h"
 #include "video_core/renderer_vulkan/present/filters.h"
@@ -41,7 +42,16 @@ void BlitScreen::SetWindowAdaptPass() {
         window_adapt = MakeNearestNeighbor(device, swapchain_view_format);
         break;
     case Settings::ScalingFilter::Bicubic:
-        window_adapt = MakeBicubic(device, swapchain_view_format);
+        window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM);
+        break;
+    case Settings::ScalingFilter::ZeroTangent:
+        window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM);
+        break;
+    case Settings::ScalingFilter::BSpline:
+        window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM);
+        break;
+    case Settings::ScalingFilter::Mitchell:
+        window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM);
         break;
     case Settings::ScalingFilter::Spline1:
         window_adapt = MakeSpline1(device, swapchain_view_format);
@@ -58,6 +68,9 @@ void BlitScreen::SetWindowAdaptPass() {
     case Settings::ScalingFilter::Area:
         window_adapt = MakeArea(device, swapchain_view_format);
         break;
+    case Settings::ScalingFilter::Mmpx:
+        window_adapt = MakeMmpx(device, swapchain_view_format);
+        break;
     case Settings::ScalingFilter::Fsr:
     case Settings::ScalingFilter::Bilinear:
     default:

src/video_core/vulkan_common/vulkan_device.h

@@ -89,7 +89,8 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION(NV, VIEWPORT_ARRAY2, viewport_array2)                                                \
     EXTENSION(NV, VIEWPORT_SWIZZLE, viewport_swizzle)                                              \
     EXTENSION(EXT, DESCRIPTOR_INDEXING, descriptor_indexing)                                       \
-    EXTENSION(EXT, FILTER_CUBIC, filter_cubic)
+    EXTENSION(EXT, FILTER_CUBIC, filter_cubic)                                                     \
+    EXTENSION(QCOM, FILTER_CUBIC_WEIGHTS, filter_cubic_weights)
 
 // Define extensions which must be supported.
 #define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
@@ -558,6 +559,11 @@ public:
         return extensions.filter_cubic;
     }
 
+    /// Returns true if the device supports VK_QCOM_filter_cubic_weights
+    bool IsQcomFilterCubicWeightsSupported() const {
+        return extensions.filter_cubic_weights;
+    }
+
     /// Returns true if the device supports VK_EXT_line_rasterization.
     bool IsExtLineRasterizationSupported() const {
         return extensions.line_rasterization;