From 632518e6e2ca3b78a17fe43636ab81a465b47177 Mon Sep 17 00:00:00 2001
From: CamilleLaVey <camillelavey99@gmail.com>
Date: Fri, 28 Nov 2025 00:37:15 -0400
Subject: [PATCH] [revert] Added linear filtering in texture blitting
 operations

---
 .../renderer_vulkan/vk_texture_cache.cpp      | 49 +++++--------------
 .../renderer_vulkan/vk_texture_cache.h        |  1 -
 2 files changed, 12 insertions(+), 38 deletions(-)

diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
index 71fc77a325..e2d932c4e9 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -739,7 +739,7 @@ void TryTransformSwizzleIfNeeded(PixelFormat format, std::array<SwizzleSource, 4
 
 void BlitScale(Scheduler& scheduler, VkImage src_image, VkImage dst_image, const ImageInfo& info,
                VkImageAspectFlags aspect_mask, const Settings::ResolutionScalingInfo& resolution,
-               bool supports_linear_filter, bool up_scaling = true) {
+               bool up_scaling = true) {
     const bool is_2d = info.type == ImageType::e2D;
     const auto resources = info.resources;
     const VkExtent2D extent{
@@ -748,8 +748,7 @@ void BlitScale(Scheduler& scheduler, VkImage src_image, VkImage dst_image, const
     };
     // Depth and integer formats must use NEAREST filter for blits.
     const bool is_color{aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT};
-    const bool is_bilinear = supports_linear_filter && is_color &&
-                             !IsPixelFormatInteger(info.format);
+    const bool is_bilinear{is_color && !IsPixelFormatInteger(info.format)};
     const VkFilter vk_filter = is_bilinear ? VK_FILTER_LINEAR : VK_FILTER_NEAREST;
 
     scheduler.RequestOutsideRenderPassOperationContext();
@@ -1154,17 +1153,12 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
     const VkImageAspectFlags aspect_mask = ImageAspectMask(src.format);
     const bool is_dst_msaa = dst.Samples() != VK_SAMPLE_COUNT_1_BIT;
     const bool is_src_msaa = src.Samples() != VK_SAMPLE_COUNT_1_BIT;
-    const bool supports_linear_filter = SupportsLinearFilter(src.format);
-    const auto effective_filter =
-        (filter == Fermi2D::Filter::Bilinear && supports_linear_filter)
-            ? Fermi2D::Filter::Bilinear
-            : Fermi2D::Filter::Point;
     if (aspect_mask != ImageAspectMask(dst.format)) {
         UNIMPLEMENTED_MSG("Incompatible blit from format {} to {}", src.format, dst.format);
         return;
     }
     if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT && !is_src_msaa && !is_dst_msaa) {
-        blit_image_helper.BlitColor(dst_framebuffer, src, dst_region, src_region, effective_filter,
+        blit_image_helper.BlitColor(dst_framebuffer, src, dst_region, src_region, filter,
                                     operation);
         return;
     }
@@ -1187,7 +1181,7 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
         if (!can_blit_depth_stencil) {
             UNIMPLEMENTED_IF(is_src_msaa || is_dst_msaa);
             blit_image_helper.BlitDepthStencil(dst_framebuffer, src, dst_region, src_region,
-                                               effective_filter, operation);
+                                               filter, operation);
             return;
         }
     }
@@ -1209,8 +1203,8 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
     }
     const bool is_resolve = is_src_msaa && !is_dst_msaa;
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([effective_filter, dst_region, src_region, dst_image, src_image, dst_layers,
-                      src_layers, aspect_mask, is_resolve](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([filter, dst_region, src_region, dst_image, src_image, dst_layers, src_layers,
+                      aspect_mask, is_resolve](vk::CommandBuffer cmdbuf) {
         const std::array read_barriers{
             VkImageMemoryBarrier{
                 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
@@ -1281,7 +1275,7 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
                                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                 MakeImageResolve(dst_region, src_region, dst_layers, src_layers));
         } else {
-            const bool is_linear = effective_filter == Fermi2D::Filter::Bilinear;
+            const bool is_linear = filter == Fermi2D::Filter::Bilinear;
             const VkFilter vk_filter = is_linear ? VK_FILTER_LINEAR : VK_FILTER_NEAREST;
             cmdbuf.BlitImage(
                 src_image, VK_IMAGE_LAYOUT_GENERAL, dst_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
@@ -1460,20 +1454,6 @@ bool TextureCacheRuntime::IsFormatScalable(PixelFormat format) {
     }
 }
 
-bool TextureCacheRuntime::SupportsLinearFilter(PixelFormat format) const {
-    if (IsPixelFormatInteger(format)) {
-        return false;
-    }
-    if (VideoCore::Surface::GetFormatType(format) != SurfaceType::ColorTexture) {
-        return false;
-    }
-    const auto vk_format =
-        MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, false, format).format;
-    constexpr VkFormatFeatureFlags linear_filter_feature =
-        VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
-    return device.IsFormatSupported(vk_format, linear_filter_feature, FormatType::Optimal);
-}
-
 void TextureCacheRuntime::CopyImage(Image& dst, Image& src,
                                     std::span<const VideoCommon::ImageCopy> copies) {
     // As per the size-compatible formats section of vulkan, copy manually via ReinterpretImage
@@ -2045,9 +2025,7 @@ bool Image::ScaleUp(bool ignore) {
     if (NeedsScaleHelper()) {
         return BlitScaleHelper(true);
     } else {
-        const bool supports_linear_filter = runtime->SupportsLinearFilter(info.format);
-        BlitScale(*scheduler, *original_image, *scaled_image, info, aspect_mask, resolution,
-                  supports_linear_filter);
+        BlitScale(*scheduler, *original_image, *scaled_image, info, aspect_mask, resolution);
     }
     return true;
 }
@@ -2072,9 +2050,7 @@ bool Image::ScaleDown(bool ignore) {
     if (NeedsScaleHelper()) {
         return BlitScaleHelper(false);
     } else {
-        const bool supports_linear_filter = runtime->SupportsLinearFilter(info.format);
-        BlitScale(*scheduler, *scaled_image, *original_image, info, aspect_mask, resolution,
-                  supports_linear_filter, false);
+        BlitScale(*scheduler, *scaled_image, *original_image, info, aspect_mask, resolution, false);
     }
     return true;
 }
@@ -2083,10 +2059,9 @@ bool Image::BlitScaleHelper(bool scale_up) {
     using namespace VideoCommon;
     static constexpr auto BLIT_OPERATION = Tegra::Engines::Fermi2D::Operation::SrcCopy;
     const bool is_color{aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT};
-    const bool supports_linear_filter = runtime->SupportsLinearFilter(info.format);
-    const bool is_bilinear = is_color && supports_linear_filter;
-    const auto filter_mode = is_bilinear ? Tegra::Engines::Fermi2D::Filter::Bilinear
-                                         : Tegra::Engines::Fermi2D::Filter::Point;
+    const bool is_bilinear{is_color && !IsPixelFormatInteger(info.format)};
+    const auto operation = is_bilinear ? Tegra::Engines::Fermi2D::Filter::Bilinear
+                                       : Tegra::Engines::Fermi2D::Filter::Point;
 
     const bool is_2d = info.type == ImageType::e2D;
     const auto& resolution = runtime->resolution;
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.h
index 9d8917a6a6..b62310a97f 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.h
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h
@@ -122,7 +122,6 @@ public:
 
     bool IsFormatDitherable(VideoCore::Surface::PixelFormat format);
     bool IsFormatScalable(VideoCore::Surface::PixelFormat format);
-    bool SupportsLinearFilter(VideoCore::Surface::PixelFormat format) const;
 
     VkFormat GetSupportedFormat(VkFormat requested_format, VkFormatFeatureFlags required_features) const;