[vk, opengl] add lanczo and spline-1 filtering (#2534)

Signed-off-by: lizzie <lizzie@eden-emu.dev>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/2534
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
Reviewed-by: Shinmegumi <shinmegumi@eden-emu.dev>
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Co-authored-by: lizzie <lizzie@eden-emu.dev>
Co-committed-by: lizzie <lizzie@eden-emu.dev>

src/video_core/host_shaders/CMakeLists.txt

@@ -1,5 +1,5 @@
-# SPDX-FileCopyrightText: 2018 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
 
 set(FIDELITYFX_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/externals/FidelityFX-FSR/ffx-fsr)
 
@@ -45,6 +45,8 @@ set(SHADER_FILES
     present_area.frag
     present_bicubic.frag
     present_gaussian.frag
+    present_lanczos.frag
+    present_spline1.frag
     queries_prefix_scan_sum.comp
     queries_prefix_scan_sum_nosubgroups.comp
     resolve_conditional_render.comp

src/video_core/host_shaders/present_lanczos.frag

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// https://en.wikipedia.org/wiki/Lanczos_resampling
+
+#version 460 core
+
+layout (location = 0) in vec2 frag_tex_coord;
+layout (location = 0) out vec4 color;
+layout (binding = 0) uniform sampler2D color_texture;
+
+#define PI 3.1415926535897932384626433
+float sinc(float x) {
+    return x == 0.0f ? 1.0f : sin(PI * x) / (PI * x);
+}
+float lanczos(vec2 v, float a) {
+    float d = length(v);
+    return sinc(d) / sinc(d / a);
+}
+vec4 textureLanczos(sampler2D textureSampler, vec2 p) {
+    vec3 c_sum = vec3(0.0f);
+    float w_sum = 0.0f;
+    vec2 res = vec2(textureSize(textureSampler, 0));
+    vec2 cc = floor(p * res) / res;
+    // kernel size = (2r + 1)^2
+    const int r = 3; //radius (1 = 3 steps)
+    for (int x = -r; x <= r; x++)
+        for (int y = -r; y <= r; y++) {
+            vec2 kp = 0.5f * (vec2(x, y) / res); // 0.5 = half-pixel level resampling
+            vec2 uv = cc + kp;
+            float w = lanczos(kp, float(r));
+            c_sum += w * texture(textureSampler, p + kp).rgb;
+            w_sum += w;
+        }
+    return vec4(c_sum / w_sum, 1.0f);
+}
+
+void main() {
+    color = textureLanczos(color_texture, frag_tex_coord);
+}

src/video_core/host_shaders/present_spline1.frag

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// Spline (smooth linear inerpolation) with 1 texel fetch (needs bilinear to work)
+// Emulates bicubic without actually doing bicubic
+// See https://iquilezles.org/articles/texture, unfortunely there are issues with the original
+// where smoothstep "expansion" actually results in worse codegen (SPIRV-Opt does a direct conv to smoothstep)
+// TODO: Numerical analysis - fract is sawtooth func and floor, reuse params? Perhaps - no need for precision
+
+#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 textureSpline1(sampler2D sam, vec2 uv) {
+    float r = float(textureSize(sam, 0).x);
+    vec2 x = fract(uv * r + 0.5);
+    return texture(sam, (floor(uv * r + 0.5) + smoothstep(0.0, 1.0, x) - 0.5) / r);
+}
+
+void main() {
+    color = textureSpline1(color_texture, frag_tex_coord);
+}

src/video_core/renderer_opengl/gl_blit_screen.cpp

@@ -89,6 +89,12 @@ void BlitScreen::CreateWindowAdapt() {
     case Settings::ScalingFilter::Gaussian:
         window_adapt = MakeGaussian(device);
         break;
+    case Settings::ScalingFilter::Spline1:
+        window_adapt = MakeSpline1(device);
+        break;
+    case Settings::ScalingFilter::Lanczos:
+        window_adapt = MakeLanczos(device);
+        break;
     case Settings::ScalingFilter::ScaleForce:
         window_adapt = MakeScaleForce(device);
         break;

src/video_core/renderer_opengl/present/filters.cpp

@@ -12,6 +12,7 @@
 #include "video_core/host_shaders/present_area_frag.h"
 #include "video_core/host_shaders/present_bicubic_frag.h"
 #include "video_core/host_shaders/present_gaussian_frag.h"
+#include "video_core/host_shaders/present_lanczos_frag.h"
 #include "video_core/renderer_opengl/present/filters.h"
 #include "video_core/renderer_opengl/present/util.h"
 
@@ -27,6 +28,11 @@ std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device) {
                                              HostShaders::OPENGL_PRESENT_FRAG);
 }
 
+std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_SPLINE1_FRAG);
+}
+
 std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device) {
     return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
                                              HostShaders::PRESENT_BICUBIC_FRAG);
@@ -37,6 +43,11 @@ std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device) {
                                              HostShaders::PRESENT_GAUSSIAN_FRAG);
 }
 
+std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_LANCZOS_FRAG);
+}
+
 std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device) {
     return std::make_unique<WindowAdaptPass>(
         device, CreateBilinearSampler(),

src/video_core/renderer_opengl/present/filters.h

@@ -18,6 +18,8 @@ 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> 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);
 

src/video_core/renderer_vulkan/present/filters.cpp

@@ -12,6 +12,7 @@
 #include "video_core/host_shaders/present_area_frag_spv.h"
 #include "video_core/host_shaders/present_bicubic_frag_spv.h"
 #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/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"
@@ -45,6 +46,11 @@ std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device, VkFormat fra
                                              BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
 }
 
+std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device, VkFormat frame_format) {
+    return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
+                                             BuildShader(device, PRESENT_SPLINE1_FRAG_SPV));
+}
+
 std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format) {
     // No need for handrolled shader -- if the VK impl can do it for us ;)
     if (device.IsExtFilterCubicSupported())
@@ -59,6 +65,11 @@ std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device, VkFormat fra
                                              BuildShader(device, PRESENT_GAUSSIAN_FRAG_SPV));
 }
 
+std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device, VkFormat frame_format) {
+    return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
+                                             BuildShader(device, PRESENT_LANCZOS_FRAG_SPV));
+}
+
 std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device, VkFormat frame_format) {
     return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
                                              SelectScaleForceShader(device));

src/video_core/renderer_vulkan/present/filters.h

@@ -18,7 +18,9 @@ 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> 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);
 

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -43,9 +43,15 @@ void BlitScreen::SetWindowAdaptPass() {
     case Settings::ScalingFilter::Bicubic:
         window_adapt = MakeBicubic(device, swapchain_view_format);
         break;
+    case Settings::ScalingFilter::Spline1:
+        window_adapt = MakeSpline1(device, swapchain_view_format);
+        break;
     case Settings::ScalingFilter::Gaussian:
         window_adapt = MakeGaussian(device, swapchain_view_format);
         break;
+    case Settings::ScalingFilter::Lanczos:
+        window_adapt = MakeLanczos(device, swapchain_view_format);
+        break;
     case Settings::ScalingFilter::ScaleForce:
         window_adapt = MakeScaleForce(device, swapchain_view_format);
         break;