GPU: Add scaling shader support

Currently only Bilinear (Sharp).

src/core/CMakeLists.txt

@@ -46,6 +46,8 @@ add_library(core
     gpu_hw.h
     gpu_hw_shadergen.cpp
     gpu_hw_shadergen.h
+    gpu_shadergen.cpp
+    gpu_shadergen.h
     gpu_sw.cpp
     gpu_sw.h
     gpu_sw_backend.cpp

src/core/core.vcxproj

@@ -39,6 +39,7 @@
     <ClCompile Include="gpu_backend.cpp" />
     <ClCompile Include="gpu_commands.cpp" />
     <ClCompile Include="gpu_hw_shadergen.cpp" />
+    <ClCompile Include="gpu_shadergen.cpp" />
     <ClCompile Include="gpu_sw.cpp" />
     <ClCompile Include="gpu_sw_backend.cpp" />
     <ClCompile Include="gte.cpp" />
@@ -103,6 +104,7 @@
     <ClInclude Include="game_list.h" />
     <ClInclude Include="gpu_backend.h" />
     <ClInclude Include="gpu_hw_shadergen.h" />
+    <ClInclude Include="gpu_shadergen.h" />
     <ClInclude Include="gpu_sw.h" />
     <ClInclude Include="gpu_sw_backend.h" />
     <ClInclude Include="gpu_types.h" />

src/core/core.vcxproj.filters

@@ -58,6 +58,7 @@
     <ClCompile Include="fullscreen_ui.cpp" />
     <ClCompile Include="achievements.cpp" />
     <ClCompile Include="hotkeys.cpp" />
+    <ClCompile Include="gpu_shadergen.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="types.h" />
@@ -120,5 +121,6 @@
     <ClInclude Include="imgui_overlays.h" />
     <ClInclude Include="fullscreen_ui.h" />
     <ClInclude Include="shader_cache_version.h" />
+    <ClInclude Include="gpu_shadergen.h" />
   </ItemGroup>
 </Project>

src/core/fullscreen_ui.cpp

@@ -3883,7 +3883,7 @@ void FullscreenUI::DrawDisplaySettingsPage()
   DrawEnumSetting(
     bsi, FSUI_CSTR("Position"), FSUI_CSTR("Determines the position on the screen when black borders must be added."),
     "Display", "Alignment", Settings::DEFAULT_DISPLAY_ALIGNMENT, &Settings::ParseDisplayAlignment,
-    &Settings::GetDisplayAlignmentDisplayName, &Settings::GetDisplayAlignmentDisplayName, DisplayAlignment::Count);
+    &Settings::GetDisplayAlignmentName, &Settings::GetDisplayAlignmentDisplayName, DisplayAlignment::Count);
 
   DrawEnumSetting(bsi, FSUI_CSTR("Downsampling"),
                   FSUI_CSTR("Downsamples the rendered image prior to displaying it. Can improve "
@@ -3892,17 +3892,11 @@ void FullscreenUI::DrawDisplaySettingsPage()
                   &Settings::GetDownsampleModeName, &Settings::GetDownsampleModeDisplayName, GPUDownsampleMode::Count,
                   (renderer != GPURenderer::Software));
 
-  DrawToggleSetting(bsi, FSUI_CSTR("Linear Upscaling"),
-                    FSUI_CSTR("Uses a bilinear filter when upscaling to display, smoothing out the image."), "Display",
-                    "LinearFiltering", true);
-
-  DrawToggleSetting(bsi, FSUI_CSTR("Integer Upscaling"),
-                    FSUI_CSTR("Adds padding to ensure pixels are a whole number in size."), "Display", "IntegerScaling",
-                    false);
-
-  DrawToggleSetting(bsi, FSUI_CSTR("Stretch To Fit"),
-                    FSUI_CSTR("Fills the window with the active display area, regardless of the aspect ratio."),
-                    "Display", "Stretch", false);
+  DrawEnumSetting(
+    bsi, FSUI_CSTR("Scaling"),
+    FSUI_CSTR("Determines how the emulated console's output is upscaled or downscaled to your monitor's resolution."),
+    "Display", "Scaling", Settings::DEFAULT_DISPLAY_SCALING, &Settings::ParseDisplayScaling,
+    &Settings::GetDisplayScalingName, &Settings::GetDisplayScalingDisplayName, DisplayScalingMode::Count);
 
   DrawToggleSetting(bsi, FSUI_CSTR("Internal Resolution Screenshots"),
                     FSUI_CSTR("Saves screenshots at internal render resolution and without postprocessing."), "Display",

src/core/gpu.cpp

@@ -1,8 +1,9 @@
-// SPDX-FileCopyrightText: 2019-2022 Connor McLaughlin <stenzek@gmail.com>
+// SPDX-FileCopyrightText: 2019-2023 Connor McLaughlin <stenzek@gmail.com>
 // SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
 
 #include "gpu.h"
 #include "dma.h"
+#include "gpu_shadergen.h"
 #include "host.h"
 #include "imgui.h"
 #include "interrupt_controller.h"
@@ -59,7 +60,7 @@ bool GPU::Initialize()
   m_console_is_pal = System::IsPALRegion();
   UpdateCRTCConfig();
 
-  if (!CompilePipelines())
+  if (!CompileDisplayPipeline())
   {
     Host::ReportErrorAsync("Error", "Failed to compile base GPU pipelines.");
     return false;
@@ -70,7 +71,7 @@ bool GPU::Initialize()
   return true;
 }
 
-void GPU::UpdateSettings()
+void GPU::UpdateSettings(const Settings& old_settings)
 {
   m_force_progressive_scan = g_settings.gpu_disable_interlacing;
   m_fifo_size = g_settings.gpu_fifo_size;
@@ -86,6 +87,12 @@ void GPU::UpdateSettings()
   // Crop mode calls this, so recalculate the display area
   UpdateCRTCDisplayParameters();
 
+  if (g_settings.display_scaling != old_settings.display_scaling)
+  {
+    if (!CompileDisplayPipeline())
+      Panic("Failed to compile display pipeline on settings change.");
+  }
+
   g_gpu_device->SetGPUTimingEnabled(g_settings.display_show_gpu);
 }
 
@@ -1540,9 +1547,9 @@ void GPU::SetTextureWindow(u32 value)
   m_draw_mode.texture_window_changed = true;
 }
 
-bool GPU::CompilePipelines()
+bool GPU::CompileDisplayPipeline()
 {
-  ShaderGen shadergen(g_gpu_device->GetRenderAPI(), g_gpu_device->GetFeatures().dual_source_blend);
+  GPUShaderGen shadergen(g_gpu_device->GetRenderAPI(), g_gpu_device->GetFeatures().dual_source_blend);
 
   GPUPipeline::GraphicsConfig plconfig;
   plconfig.layout = GPUPipeline::Layout::SingleTextureAndPushConstants;
@@ -1556,20 +1563,35 @@ bool GPU::CompilePipelines()
   plconfig.samples = 1;
   plconfig.per_sample_shading = false;
 
-  std::unique_ptr<GPUShader> display_vs =
-    g_gpu_device->CreateShader(GPUShaderStage::Vertex, shadergen.GenerateDisplayVertexShader());
-  std::unique_ptr<GPUShader> display_fs =
-    g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GenerateDisplayFragmentShader(true));
-  if (!display_vs || !display_fs)
+  std::string vs = shadergen.GenerateDisplayVertexShader();
+  std::string fs;
+  switch (g_settings.display_scaling)
+  {
+    case DisplayScalingMode::BilinearSharp:
+      fs = shadergen.GenerateDisplaySharpBilinearFragmentShader();
+      break;
+
+    case DisplayScalingMode::Nearest:
+    case DisplayScalingMode::BilinearSmooth:
+    case DisplayScalingMode::NearestInteger:
+    default:
+      fs = shadergen.GenerateDisplayFragmentShader();
+      break;
+  }
+
+  std::unique_ptr<GPUShader> vso = g_gpu_device->CreateShader(GPUShaderStage::Vertex, vs);
+  std::unique_ptr<GPUShader> fso = g_gpu_device->CreateShader(GPUShaderStage::Fragment, fs);
+  if (!vso || !fso)
     return false;
-  GL_OBJECT_NAME(display_vs, "Display Vertex Shader");
-  GL_OBJECT_NAME(display_fs, "Display Fragment Shader");
+  GL_OBJECT_NAME(vso, "Display Vertex Shader");
+  GL_OBJECT_NAME(fso, "Display Fragment Shader [%s]", Settings::GetDisplayScalingName(g_settings.display_scaling));
 
-  plconfig.vertex_shader = display_vs.get();
-  plconfig.fragment_shader = display_fs.get();
+  plconfig.vertex_shader = vso.get();
+  plconfig.fragment_shader = fso.get();
   if (!(m_display_pipeline = g_gpu_device->CreatePipeline(plconfig)))
     return false;
-  GL_OBJECT_NAME(m_display_pipeline, "Display Pipeline");
+  GL_OBJECT_NAME(m_display_pipeline, "Display Pipeline [%s]",
+                 Settings::GetDisplayScalingName(g_settings.display_scaling));
 
   return true;
 }
@@ -1620,17 +1642,56 @@ bool GPU::PresentDisplay()
 
   const Common::Rectangle<s32> draw_rect =
     CalculateDrawRect(g_gpu_device->GetWindowWidth(), g_gpu_device->GetWindowHeight());
-  return RenderDisplay(nullptr, draw_rect, g_settings.display_linear_filtering, true);
+  return RenderDisplay(nullptr, draw_rect, true);
 }
 
-bool GPU::RenderDisplay(GPUFramebuffer* target, const Common::Rectangle<s32>& draw_rect, bool linear_filter,
-                        bool postfx)
+bool GPU::RenderDisplay(GPUFramebuffer* target, const Common::Rectangle<s32>& draw_rect, bool postfx)
 {
   GL_SCOPE("RenderDisplay: %dx%d at %d,%d", draw_rect.left, draw_rect.top, draw_rect.GetWidth(), draw_rect.GetHeight());
 
   if (m_display_texture)
     m_display_texture->MakeReadyForSampling();
 
+  bool texture_filter_linear = false;
+  bool bilinear_adjust = false;
+
+  struct Uniforms
+  {
+    float src_rect[4];
+    float src_size[4];
+    float params[4];
+  } uniforms;
+  std::memset(uniforms.params, 0, sizeof(uniforms.params));
+
+  switch (g_settings.display_scaling)
+  {
+    case DisplayScalingMode::Nearest:
+    case DisplayScalingMode::NearestInteger:
+      break;
+
+    case DisplayScalingMode::BilinearSmooth:
+      texture_filter_linear = true;
+      bilinear_adjust = true;
+      break;
+
+    case DisplayScalingMode::BilinearSharp:
+    {
+      texture_filter_linear = true;
+      uniforms.params[0] = std::max(
+        std::floor(static_cast<float>(draw_rect.GetWidth()) / static_cast<float>(m_display_texture_view_width)), 1.0f);
+      uniforms.params[1] = std::max(
+        std::floor(static_cast<float>(draw_rect.GetHeight()) / static_cast<float>(m_display_texture_view_height)),
+        1.0f);
+      uniforms.params[2] = 0.5f - 0.5f / uniforms.params[0];
+      uniforms.params[3] = 0.5f - 0.5f / uniforms.params[1];
+    }
+    break;
+
+    default:
+      UnreachableCode();
+      break;
+  }
+
   const GPUTexture::Format hdformat =
     (target && target->GetRT()) ? target->GetRT()->GetFormat() : g_gpu_device->GetWindowFormat();
   const u32 target_width = target ? target->GetWidth() : g_gpu_device->GetWindowWidth();
@@ -1654,29 +1715,30 @@ bool GPU::RenderDisplay(GPUFramebuffer* target, const Common::Rectangle<s32>& dr
     return true;
 
   g_gpu_device->SetPipeline(m_display_pipeline.get());
-  g_gpu_device->SetTextureSampler(0, m_display_texture,
-                                  linear_filter ? g_gpu_device->GetLinearSampler() : g_gpu_device->GetNearestSampler());
-
-  const float position_adjust = linear_filter ? 0.5f : 0.0f;
-  const float size_adjust = linear_filter ? 1.0f : 0.0f;
-  const float uniforms[4] = {(static_cast<float>(m_display_texture_view_x) + position_adjust) /
-                               static_cast<float>(m_display_texture->GetWidth()),
-                             (static_cast<float>(m_display_texture_view_y) + position_adjust) /
-                               static_cast<float>(m_display_texture->GetHeight()),
-                             (static_cast<float>(m_display_texture_view_width) - size_adjust) /
-                               static_cast<float>(m_display_texture->GetWidth()),
-                             (static_cast<float>(m_display_texture_view_height) - size_adjust) /
-                               static_cast<float>(m_display_texture->GetHeight())};
-  g_gpu_device->PushUniformBuffer(uniforms, sizeof(uniforms));
+  g_gpu_device->SetTextureSampler(
+    0, m_display_texture, texture_filter_linear ? g_gpu_device->GetLinearSampler() : g_gpu_device->GetNearestSampler());
+
+  const float position_adjust = bilinear_adjust ? 0.5f : 0.0f;
+  const float size_adjust = bilinear_adjust ? 1.0f : 0.0f;
+  const float rcp_width = 1.0f / static_cast<float>(m_display_texture->GetWidth());
+  const float rcp_height = 1.0f / static_cast<float>(m_display_texture->GetHeight());
+  uniforms.src_rect[0] = (static_cast<float>(m_display_texture_view_x) + position_adjust) * rcp_width;
+  uniforms.src_rect[1] = (static_cast<float>(m_display_texture_view_y) + position_adjust) * rcp_height;
+  uniforms.src_rect[2] = (static_cast<float>(m_display_texture_view_width) - size_adjust) * rcp_width;
+  uniforms.src_rect[3] = (static_cast<float>(m_display_texture_view_height) - size_adjust) * rcp_height;
+  uniforms.src_size[0] = static_cast<float>(m_display_texture->GetWidth());
+  uniforms.src_size[1] = static_cast<float>(m_display_texture->GetHeight());
+  uniforms.src_size[2] = rcp_width;
+  uniforms.src_size[3] = rcp_height;
+  g_gpu_device->PushUniformBuffer(&uniforms, sizeof(uniforms));
 
   g_gpu_device->SetViewportAndScissor(draw_rect.left, draw_rect.top, draw_rect.GetWidth(), draw_rect.GetHeight());
   g_gpu_device->Draw(3, 0);
 
   if (really_postfx)
   {
-    return PostProcessing::Apply(target, draw_rect.left, draw_rect.top, draw_rect.GetWidth(),
-                                          draw_rect.GetHeight(), m_display_texture_view_width,
-                                          m_display_texture_view_height);
+    return PostProcessing::Apply(target, draw_rect.left, draw_rect.top, draw_rect.GetWidth(), draw_rect.GetHeight(),
+                                 m_display_texture_view_width, m_display_texture_view_height);
   }
   else
   {
@@ -1689,10 +1751,9 @@ Common::Rectangle<float> GPU::CalculateDrawRect(s32 window_width, s32 window_hei
                                                 bool apply_aspect_ratio /* = true */) const
 {
   const float window_ratio = static_cast<float>(window_width) / static_cast<float>(window_height);
-  const float display_aspect_ratio = g_settings.display_stretch ? window_ratio : m_display_aspect_ratio;
   const float x_scale =
     apply_aspect_ratio ?
-      (display_aspect_ratio / (static_cast<float>(m_display_width) / static_cast<float>(m_display_height))) :
+      (m_display_aspect_ratio / (static_cast<float>(m_display_width) / static_cast<float>(m_display_height))) :
       1.0f;
   const float display_width = g_settings.display_stretch_vertically ? static_cast<float>(m_display_width) :
                                                                       static_cast<float>(m_display_width) * x_scale;
@@ -1717,12 +1778,12 @@ Common::Rectangle<float> GPU::CalculateDrawRect(s32 window_width, s32 window_hei
   {
     // align in middle vertically
     scale = static_cast<float>(window_width) / display_width;
-    if (g_settings.display_integer_scaling)
+    if (g_settings.display_scaling == DisplayScalingMode::NearestInteger)
       scale = std::max(std::floor(scale), 1.0f);
 
     if (out_left_padding)
     {
-      if (g_settings.display_integer_scaling)
+      if (g_settings.display_scaling == DisplayScalingMode::NearestInteger)
         *out_left_padding = std::max<float>((static_cast<float>(window_width) - display_width * scale) / 2.0f, 0.0f);
       else
         *out_left_padding = 0.0f;
@@ -1751,7 +1812,7 @@ Common::Rectangle<float> GPU::CalculateDrawRect(s32 window_width, s32 window_hei
   {
     // align in middle horizontally
     scale = static_cast<float>(window_height) / display_height;
-    if (g_settings.display_integer_scaling)
+    if (g_settings.display_scaling == DisplayScalingMode::NearestInteger)
       scale = std::max(std::floor(scale), 1.0f);
 
     if (out_left_padding)
@@ -1776,7 +1837,7 @@ Common::Rectangle<float> GPU::CalculateDrawRect(s32 window_width, s32 window_hei
 
     if (out_top_padding)
     {
-      if (g_settings.display_integer_scaling)
+      if (g_settings.display_scaling == DisplayScalingMode::NearestInteger)
         *out_top_padding = std::max<float>((static_cast<float>(window_height) - (display_height * scale)) / 2.0f, 0.0f);
       else
         *out_top_padding = 0.0f;
@@ -1974,7 +2035,8 @@ bool GPU::RenderScreenshotToBuffer(u32 width, u32 height, const Common::Rectangl
 
   g_gpu_device->ClearRenderTarget(render_texture.get(), 0);
 
-  RenderDisplay(render_fb.get(), draw_rect, g_settings.display_linear_filtering, postfx);
+  // TODO: this should use copy shader instead.
+  RenderDisplay(render_fb.get(), draw_rect, postfx);
 
   g_gpu_device->SetFramebuffer(nullptr);
 

src/core/gpu.h

@@ -27,6 +27,7 @@ class GPUFramebuffer;
 class GPUTexture;
 class GPUPipeline;
 
+struct Settings;
 class TimingEvent;
 
 namespace Threading {
@@ -151,7 +152,7 @@ public:
   void SynchronizeCRTC();
 
   /// Recompile shaders/recreate framebuffers when needed.
-  virtual void UpdateSettings();
+  virtual void UpdateSettings(const Settings& old_settings);
 
   /// Updates the resolution scale when it's set to automatic.
   virtual void UpdateResolutionScale();
@@ -582,7 +583,7 @@ protected:
                                              float* out_top_padding, float* out_scale, float* out_x_scale,
                                              bool apply_aspect_ratio = true) const;
 
-  bool RenderDisplay(GPUFramebuffer* target, const Common::Rectangle<s32>& draw_rect, bool linear_filter, bool postfx);
+  bool RenderDisplay(GPUFramebuffer* target, const Common::Rectangle<s32>& draw_rect, bool postfx);
 
   s32 m_display_width = 0;
   s32 m_display_height = 0;
@@ -612,7 +613,7 @@ protected:
   Stats m_last_stats = {};
 
 private:
-  bool CompilePipelines();
+  bool CompileDisplayPipeline();
 
   using GP0CommandHandler = bool (GPU::*)();
   using GP0CommandHandlerTable = std::array<GP0CommandHandler, 256>;

src/core/gpu_hw.cpp

@@ -286,9 +286,9 @@ void GPU_HW::RestoreGraphicsAPIState()
   m_batch_ubo_dirty = true;
 }
 
-void GPU_HW::UpdateSettings()
+void GPU_HW::UpdateSettings(const Settings& old_settings)
 {
-  GPU::UpdateSettings();
+  GPU::UpdateSettings(old_settings);
 
   const u32 resolution_scale = CalculateResolutionScale();
   const u32 multisamples = std::min(g_settings.gpu_multisamples, g_gpu_device->GetMaxMultisamples());
@@ -297,6 +297,7 @@ void GPU_HW::UpdateSettings()
   const bool use_uv_limits = ShouldUseUVLimits();
   const bool disable_color_perspective = m_supports_disable_color_perspective && ShouldDisableColorPerspective();
 
+  // TODO: Use old_settings
   const bool framebuffer_changed =
     (m_resolution_scale != resolution_scale || m_multisamples != multisamples || m_downsample_mode != downsample_mode);
   const bool shaders_changed =
@@ -429,7 +430,7 @@ void GPU_HW::UpdateResolutionScale()
   GPU::UpdateResolutionScale();
 
   if (CalculateResolutionScale() != m_resolution_scale)
-    UpdateSettings();
+    UpdateSettings(g_settings);
 }
 
 GPUDownsampleMode GPU_HW::GetDownsampleMode(u32 resolution_scale) const

src/core/gpu_hw.h

@@ -51,7 +51,7 @@ public:
 
   void RestoreGraphicsAPIState() override;
 
-  void UpdateSettings() override;
+  void UpdateSettings(const Settings& old_settings) override;
   void UpdateResolutionScale() override final;
   std::tuple<u32, u32> GetEffectiveDisplayResolution(bool scaled = true) override final;
   std::tuple<u32, u32> GetFullDisplayResolution(bool scaled = true) override final;

src/core/gpu_shadergen.cpp

@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: 2019-2023 Connor McLaughlin <stenzek@gmail.com>
+// SPDX-License-Identifier: GPL-3.0
+
+#include "gpu_shadergen.h"
+
+GPUShaderGen::GPUShaderGen(RenderAPI render_api, bool supports_dual_source_blend)
+  : ShaderGen(render_api, supports_dual_source_blend)
+{
+}
+
+GPUShaderGen::~GPUShaderGen() = default;
+
+void GPUShaderGen::WriteDisplayUniformBuffer(std::stringstream& ss)
+{
+  DeclareUniformBuffer(ss, {"float4 u_src_rect", "float4 u_src_size", "float4 u_params"}, true);
+}
+
+std::string GPUShaderGen::GenerateDisplayVertexShader()
+{
+  std::stringstream ss;
+  WriteHeader(ss);
+  WriteDisplayUniformBuffer(ss);
+  DeclareVertexEntryPoint(ss, {}, 0, 1, {}, true);
+  ss << R"(
+{
+  float2 pos = float2(float((v_id << 1) & 2u), float(v_id & 2u));
+  v_tex0 = u_src_rect.xy + pos * u_src_rect.zw;
+  v_pos = float4(pos * float2(2.0f, -2.0f) + float2(-1.0f, 1.0f), 0.0f, 1.0f);
+  #if API_VULKAN
+    v_pos.y = -v_pos.y;
+  #endif
+}
+)";
+
+  return ss.str();
+}
+
+std::string GPUShaderGen::GenerateDisplayFragmentShader()
+{
+  std::stringstream ss;
+  WriteHeader(ss);
+  WriteDisplayUniformBuffer(ss);
+  DeclareTexture(ss, "samp0", 0);
+  DeclareFragmentEntryPoint(ss, 0, 1, {}, false, 1);
+  ss << R"(
+{
+  o_col0 = float4(SAMPLE_TEXTURE(samp0, v_tex0).rgb, 1.0f);
+})";
+
+  return ss.str();
+}
+
+std::string GPUShaderGen::GenerateDisplaySharpBilinearFragmentShader()
+{
+  std::stringstream ss;
+  WriteHeader(ss);
+  WriteDisplayUniformBuffer(ss);
+  DeclareTexture(ss, "samp0", 0, false);
+
+  // Based on https://github.com/rsn8887/Sharp-Bilinear-Shaders/blob/master/Copy_To_RetroPie/shaders/sharp-bilinear-simple.glsl
+  DeclareFragmentEntryPoint(ss, 0, 1, {}, false, 1, false, false, false, false);
+  ss << R"(
+{
+  float2 scale = u_params.xy;
+  float2 region_range = u_params.zw;
+
+  float2 texel = v_tex0 * u_src_size.xy;
+  float2 texel_floored = floor(texel);
+  float2 s = frac(texel);
+
+  float2 center_dist = s - 0.5;
+  float2 f = (center_dist - clamp(center_dist, -region_range, region_range)) * scale + 0.5;
+  float2 mod_texel = texel_floored + f;
+
+  o_col0 = float4(SAMPLE_TEXTURE(samp0, mod_texel * u_src_size.zw).rgb, 1.0f);
+})";
+
+  return ss.str();
+}

src/core/gpu_shadergen.h

@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: 2019-2023 Connor McLaughlin <stenzek@gmail.com>
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include "util/shadergen.h"
+
+class GPUShaderGen : public ShaderGen
+{
+public:
+  GPUShaderGen(RenderAPI render_api, bool supports_dual_source_blend);
+  ~GPUShaderGen();
+
+  std::string GenerateDisplayVertexShader();
+  std::string GenerateDisplayFragmentShader();
+  std::string GenerateDisplaySharpBilinearFragmentShader();
+
+private:
+  void WriteDisplayUniformBuffer(std::stringstream& ss);
+};

src/core/gpu_sw.cpp

@@ -97,9 +97,9 @@ void GPU_SW::Reset(bool clear_vram)
   m_backend.Reset(clear_vram);
 }
 
-void GPU_SW::UpdateSettings()
+void GPU_SW::UpdateSettings(const Settings& old_settings)
 {
-  GPU::UpdateSettings();
+  GPU::UpdateSettings(old_settings);
   m_backend.UpdateSettings();
 }
 

src/core/gpu_sw.h

@@ -33,7 +33,7 @@ public:
   bool Initialize() override;
   bool DoState(StateWrapper& sw, GPUTexture** host_texture, bool update_display) override;
   void Reset(bool clear_vram) override;
-  void UpdateSettings() override;
+  void UpdateSettings(const Settings& old_settings) override;
 
 protected:
   void ReadVRAM(u32 x, u32 y, u32 width, u32 height) override;

src/core/hotkeys.cpp

@@ -48,12 +48,13 @@ static void HotkeyModifyResolutionScale(s32 increment)
   if (new_resolution_scale == g_settings.gpu_resolution_scale)
     return;
 
+  const Settings old_settings = g_settings;
   g_settings.gpu_resolution_scale = new_resolution_scale;
 
   if (System::IsValid())
   {
     g_gpu->RestoreGraphicsAPIState();
-    g_gpu->UpdateSettings();
+    g_gpu->UpdateSettings(old_settings);
     System::ClearMemorySaveStates();
   }
 }
@@ -309,9 +310,10 @@ DEFINE_HOTKEY("TogglePGXP", TRANSLATE_NOOP("Hotkeys", "Graphics"), TRANSLATE_NOO
               [](s32 pressed) {
                 if (!pressed && System::IsValid())
                 {
+                  Settings old_settings = g_settings;
                   g_settings.gpu_pgxp_enable = !g_settings.gpu_pgxp_enable;
                   g_gpu->RestoreGraphicsAPIState();
-                  g_gpu->UpdateSettings();
+                  g_gpu->UpdateSettings(old_settings);
                   System::ClearMemorySaveStates();
                   Host::AddKeyedOSDMessage("TogglePGXP",
                                            g_settings.gpu_pgxp_enable ?
@@ -374,12 +376,14 @@ DEFINE_HOTKEY("TogglePGXPDepth", TRANSLATE_NOOP("Hotkeys", "Graphics"),
               TRANSLATE_NOOP("Hotkeys", "Toggle PGXP Depth Buffer"), [](s32 pressed) {
                 if (!pressed && System::IsValid())
                 {
-                  g_settings.gpu_pgxp_depth_buffer = !g_settings.gpu_pgxp_depth_buffer;
                   if (!g_settings.gpu_pgxp_enable)
                     return;
 
+                  const Settings old_settings = g_settings;
+                  g_settings.gpu_pgxp_depth_buffer = !g_settings.gpu_pgxp_depth_buffer;
+
                   g_gpu->RestoreGraphicsAPIState();
-                  g_gpu->UpdateSettings();
+                  g_gpu->UpdateSettings(old_settings);
                   System::ClearMemorySaveStates();
                   Host::AddKeyedOSDMessage("TogglePGXPDepth",
                                            g_settings.gpu_pgxp_depth_buffer ?
@@ -393,12 +397,14 @@ DEFINE_HOTKEY("TogglePGXPCPU", TRANSLATE_NOOP("Hotkeys", "Graphics"), TRANSLATE_
               [](s32 pressed) {
                 if (pressed && System::IsValid())
                 {
-                  g_settings.gpu_pgxp_cpu = !g_settings.gpu_pgxp_cpu;
                   if (!g_settings.gpu_pgxp_enable)
                     return;
 
+                  const Settings old_settings = g_settings;
+                  g_settings.gpu_pgxp_cpu = !g_settings.gpu_pgxp_cpu;
+
                   g_gpu->RestoreGraphicsAPIState();
-                  g_gpu->UpdateSettings();
+                  g_gpu->UpdateSettings(old_settings);
                   System::ClearMemorySaveStates();
                   Host::AddKeyedOSDMessage("TogglePGXPCPU",
                                            g_settings.gpu_pgxp_cpu ?

src/core/settings.cpp

@@ -256,14 +256,14 @@ void Settings::Load(SettingsInterface& si)
     ParseDisplayAlignment(
       si.GetStringValue("Display", "Alignment", GetDisplayAlignmentName(DEFAULT_DISPLAY_ALIGNMENT)).c_str())
     .value_or(DEFAULT_DISPLAY_ALIGNMENT);
+  display_scaling =
+    ParseDisplayScaling(si.GetStringValue("Display", "Scaling", GetDisplayScalingName(DEFAULT_DISPLAY_SCALING)).c_str())
+    .value_or(DEFAULT_DISPLAY_SCALING);
   display_force_4_3_for_24bit = si.GetBoolValue("Display", "Force4_3For24Bit", false);
   display_active_start_offset = static_cast<s16>(si.GetIntValue("Display", "ActiveStartOffset", 0));
   display_active_end_offset = static_cast<s16>(si.GetIntValue("Display", "ActiveEndOffset", 0));
   display_line_start_offset = static_cast<s8>(si.GetIntValue("Display", "LineStartOffset", 0));
   display_line_end_offset = static_cast<s8>(si.GetIntValue("Display", "LineEndOffset", 0));
-  display_linear_filtering = si.GetBoolValue("Display", "LinearFiltering", true);
-  display_integer_scaling = si.GetBoolValue("Display", "IntegerScaling", false);
-  display_stretch = si.GetBoolValue("Display", "Stretch", false);
   display_show_osd_messages = si.GetBoolValue("Display", "ShowOSDMessages", true);
   display_show_fps = si.GetBoolValue("Display", "ShowFPS", false);
   display_show_speed = si.GetBoolValue("Display", "ShowSpeed", false);
@@ -401,6 +401,12 @@ void Settings::Load(SettingsInterface& si)
     si.GetIntValue("TextureReplacements", "DumpVRAMWriteWidthThreshold", 128);
   texture_replacements.dump_vram_write_height_threshold =
     si.GetIntValue("TextureReplacements", "DumpVRAMWriteHeightThreshold", 128);
+
+#ifdef __ANDROID__
+  // Android users are incredibly silly and don't understand that stretch is in the aspect ratio list...
+  if (si.GetBoolValue("Display", "Stretch", false))
+    display_aspect_ratio = DisplayAspectRatio::MatchWindow;
+#endif
 }
 
 void Settings::Save(SettingsInterface& si) const
@@ -479,11 +485,9 @@ void Settings::Save(SettingsInterface& si) const
   si.SetBoolValue("Display", "Force4_3For24Bit", display_force_4_3_for_24bit);
   si.SetStringValue("Display", "AspectRatio", GetDisplayAspectRatioName(display_aspect_ratio));
   si.SetStringValue("Display", "Alignment", GetDisplayAlignmentName(display_alignment));
+  si.SetBoolValue("Display", "Scaling", GetDisplayScalingName(display_scaling));
   si.SetIntValue("Display", "CustomAspectRatioNumerator", display_aspect_ratio_custom_numerator);
   si.GetIntValue("Display", "CustomAspectRatioDenominator", display_aspect_ratio_custom_denominator);
-  si.SetBoolValue("Display", "LinearFiltering", display_linear_filtering);
-  si.SetBoolValue("Display", "IntegerScaling", display_integer_scaling);
-  si.SetBoolValue("Display", "Stretch", display_stretch);
   si.SetBoolValue("Display", "ShowOSDMessages", display_show_osd_messages);
   si.SetBoolValue("Display", "ShowFPS", display_show_fps);
   si.SetBoolValue("Display", "ShowSpeed", display_show_speed);
@@ -628,18 +632,6 @@ void Settings::FixIncompatibleSettings(bool display_osd_messages)
     g_settings.pcdrv_enable = false;
   }
 
-  if (g_settings.display_integer_scaling && g_settings.display_linear_filtering)
-  {
-    Log_WarningPrintf("Disabling linear filter due to integer upscaling.");
-    g_settings.display_linear_filtering = false;
-  }
-
-  if (g_settings.display_integer_scaling && g_settings.display_stretch)
-  {
-    Log_WarningPrintf("Disabling stretch due to integer upscaling.");
-    g_settings.display_stretch = false;
-  }
-
   if (g_settings.gpu_pgxp_enable)
   {
     if (g_settings.gpu_renderer == GPURenderer::Software)
@@ -1091,7 +1083,7 @@ const char* Settings::GetDisplayCropModeDisplayName(DisplayCropMode crop_mode)
 
 static std::array<const char*, static_cast<size_t>(DisplayAspectRatio::Count)> s_display_aspect_ratio_names = {
   {TRANSLATE_NOOP("DisplayAspectRatio", "Auto (Game Native)"),
-   TRANSLATE_NOOP("DisplayAspectRatio", "Auto (Match Window)"), TRANSLATE_NOOP("DisplayAspectRatio", "Custom"), "4:3",
+   TRANSLATE_NOOP("DisplayAspectRatio", "Stretch To Fill"), TRANSLATE_NOOP("DisplayAspectRatio", "Custom"), "4:3",
    "16:9", "19:9", "20:9", "PAR 1:1"}};
 static constexpr std::array<float, static_cast<size_t>(DisplayAspectRatio::Count)> s_display_aspect_ratio_values = {
   {-1.0f, -1.0f, -1.0f, 4.0f / 3.0f, 16.0f / 9.0f, 19.0f / 9.0f, 20.0f / 9.0f, -1.0f}};
@@ -1172,7 +1164,44 @@ const char* Settings::GetDisplayAlignmentName(DisplayAlignment alignment)
 
 const char* Settings::GetDisplayAlignmentDisplayName(DisplayAlignment alignment)
 {
-  return s_display_alignment_display_names[static_cast<int>(alignment)];
+  return Host::TranslateToCString("DisplayAlignment", s_display_alignment_display_names[static_cast<int>(alignment)]);
+}
+
+static std::array<const char*, static_cast<size_t>(DisplayScalingMode::Count)> s_display_scaling_names = {{
+  "Nearest",
+  "BilinearSmooth",
+  "NearestInteger",
+  "BilinearSharp",
+}};
+static std::array<const char*, static_cast<size_t>(DisplayScalingMode::Count)> s_display_scaling_display_names = {{
+  TRANSLATE_NOOP("DisplayScalingMode", "Nearest-Neighbor"),
+  TRANSLATE_NOOP("DisplayScalingMode", "Bilinear (Smooth)"),
+  TRANSLATE_NOOP("DisplayScalingMode", "Nearest-Neighbor (Integer)"),
+  TRANSLATE_NOOP("DisplayScalingMode", "Bilinear (Sharp)"),
+}};
+
+std::optional<DisplayScalingMode> Settings::ParseDisplayScaling(const char* str)
+{
+  int index = 0;
+  for (const char* name : s_display_scaling_names)
+  {
+    if (StringUtil::Strcasecmp(name, str) == 0)
+      return static_cast<DisplayScalingMode>(index);
+
+    index++;
+  }
+
+  return std::nullopt;
+}
+
+const char* Settings::GetDisplayScalingName(DisplayScalingMode mode)
+{
+  return s_display_scaling_names[static_cast<int>(mode)];
+}
+
+const char* Settings::GetDisplayScalingDisplayName(DisplayScalingMode mode)
+{
+  return Host::TranslateToCString("DisplayScalingMode", s_display_scaling_display_names[static_cast<int>(mode)]);
 }
 
 static constexpr const char* s_audio_backend_names[] = {
@@ -1470,8 +1499,12 @@ bool EmuFolders::EnsureFoldersExist()
   result = FileSystem::EnsureDirectoryExists(Screenshots.c_str(), false) && result;
   result = FileSystem::EnsureDirectoryExists(Shaders.c_str(), false) && result;
   result = FileSystem::EnsureDirectoryExists(Path::Combine(Shaders, "reshade").c_str(), false) && result;
-  result = FileSystem::EnsureDirectoryExists(Path::Combine(Shaders, "reshade" FS_OSPATH_SEPARATOR_STR "Shaders").c_str(), false) && result;
-  result = FileSystem::EnsureDirectoryExists(Path::Combine(Shaders, "reshade" FS_OSPATH_SEPARATOR_STR "Textures").c_str(), false) && result;
+  result = FileSystem::EnsureDirectoryExists(
+             Path::Combine(Shaders, "reshade" FS_OSPATH_SEPARATOR_STR "Shaders").c_str(), false) &&
+           result;
+  result = FileSystem::EnsureDirectoryExists(
+             Path::Combine(Shaders, "reshade" FS_OSPATH_SEPARATOR_STR "Textures").c_str(), false) &&
+           result;
   result = FileSystem::EnsureDirectoryExists(Textures.c_str(), false) && result;
   return result;
 }

src/core/settings.h

@@ -120,6 +120,7 @@ struct Settings
   DisplayCropMode display_crop_mode = DEFAULT_DISPLAY_CROP_MODE;
   DisplayAspectRatio display_aspect_ratio = DEFAULT_DISPLAY_ASPECT_RATIO;
   DisplayAlignment display_alignment = DEFAULT_DISPLAY_ALIGNMENT;
+  DisplayScalingMode display_scaling = DEFAULT_DISPLAY_SCALING;
   u16 display_aspect_ratio_custom_numerator = 0;
   u16 display_aspect_ratio_custom_denominator = 0;
   s16 display_active_start_offset = 0;
@@ -128,9 +129,6 @@ struct Settings
   s8 display_line_end_offset = 0;
   bool display_force_4_3_for_24bit = false;
   bool gpu_24bit_chroma_smoothing = false;
-  bool display_linear_filtering = true;
-  bool display_integer_scaling = false;
-  bool display_stretch = false;
   bool display_show_osd_messages = true;
   bool display_show_fps = false;
   bool display_show_speed = false;
@@ -387,6 +385,10 @@ struct Settings
   static const char* GetDisplayAlignmentName(DisplayAlignment alignment);
   static const char* GetDisplayAlignmentDisplayName(DisplayAlignment alignment);
 
+  static std::optional<DisplayScalingMode> ParseDisplayScaling(const char* str);
+  static const char* GetDisplayScalingName(DisplayScalingMode mode);
+  static const char* GetDisplayScalingDisplayName(DisplayScalingMode mode);
+
   static std::optional<AudioBackend> ParseAudioBackend(const char* str);
   static const char* GetAudioBackendName(AudioBackend backend);
   static const char* GetAudioBackendDisplayName(AudioBackend backend);
@@ -448,6 +450,7 @@ struct Settings
   static constexpr DisplayCropMode DEFAULT_DISPLAY_CROP_MODE = DisplayCropMode::Overscan;
   static constexpr DisplayAspectRatio DEFAULT_DISPLAY_ASPECT_RATIO = DisplayAspectRatio::Auto;
   static constexpr DisplayAlignment DEFAULT_DISPLAY_ALIGNMENT = DisplayAlignment::Center;
+  static constexpr DisplayScalingMode DEFAULT_DISPLAY_SCALING = DisplayScalingMode::BilinearSmooth;
   static constexpr float DEFAULT_OSD_SCALE = 100.0f;
 
   static constexpr u8 DEFAULT_CDROM_READAHEAD_SECTORS = 8;

src/core/system.cpp

@@ -3592,6 +3592,7 @@ void System::CheckForSettingsChanges(const Settings& old_settings)
         g_settings.display_crop_mode != old_settings.display_crop_mode ||
         g_settings.display_aspect_ratio != old_settings.display_aspect_ratio ||
         g_settings.display_alignment != old_settings.display_alignment ||
+        g_settings.display_scaling != old_settings.display_scaling ||
         g_settings.display_show_gpu != old_settings.display_show_gpu ||
         g_settings.gpu_pgxp_enable != old_settings.gpu_pgxp_enable ||
         g_settings.gpu_pgxp_texture_correction != old_settings.gpu_pgxp_texture_correction ||
@@ -3604,7 +3605,7 @@ void System::CheckForSettingsChanges(const Settings& old_settings)
         g_settings.rewind_enable != old_settings.rewind_enable ||
         g_settings.runahead_frames != old_settings.runahead_frames)
     {
-      g_gpu->UpdateSettings();
+      g_gpu->UpdateSettings(old_settings);
       InvalidateDisplay();
     }
 

src/core/types.h

@@ -116,7 +116,7 @@ enum class DisplayAspectRatio : u8
   Count
 };
 
-enum class DisplayAlignment
+enum class DisplayAlignment : u8
 {
   LeftOrTop,
   Center,
@@ -124,6 +124,15 @@ enum class DisplayAlignment
   Count
 };
 
+enum class DisplayScalingMode : u8
+{
+  Nearest,
+  BilinearSmooth,
+  NearestInteger,
+  BilinearSharp,
+  Count
+};
+
 enum class AudioBackend : u8
 {
   Null,

src/duckstation-qt/displaysettingswidget.cpp

@@ -41,9 +41,9 @@ DisplaySettingsWidget::DisplaySettingsWidget(SettingsDialog* dialog, QWidget* pa
   SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.displayAlignment, "Display", "Alignment",
                                                &Settings::ParseDisplayAlignment, &Settings::GetDisplayAlignmentName,
                                                Settings::DEFAULT_DISPLAY_ALIGNMENT);
-  SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.displayLinearFiltering, "Display", "LinearFiltering", true);
-  SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.displayIntegerScaling, "Display", "IntegerScaling", false);
-  SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.displayStretch, "Display", "Stretch", false);
+  SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.displayScaling, "Display", "Scaling",
+                                               &Settings::ParseDisplayScaling, &Settings::GetDisplayScalingName,
+                                               Settings::DEFAULT_DISPLAY_SCALING);
   SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.internalResolutionScreenshots, "Display",
                                                "InternalResolutionScreenshots", false);
   SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.vsync, "Display", "VSync", false);
@@ -66,10 +66,7 @@ DisplaySettingsWidget::DisplaySettingsWidget(SettingsDialog* dialog, QWidget* pa
           &DisplaySettingsWidget::onGPUFullscreenModeIndexChanged);
   connect(m_ui.displayAspectRatio, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
           &DisplaySettingsWidget::onAspectRatioChanged);
-  connect(m_ui.displayIntegerScaling, &QCheckBox::stateChanged, this,
-          &DisplaySettingsWidget::onIntegerFilteringChanged);
   populateGPUAdaptersAndResolutions();
-  onIntegerFilteringChanged();
   onAspectRatioChanged();
 
   dialog->registerWidgetHelp(
@@ -100,18 +97,9 @@ DisplaySettingsWidget::DisplaySettingsWidget(SettingsDialog* dialog, QWidget* pa
     m_ui.displayAlignment, tr("Position"),
     QString::fromUtf8(Settings::GetDisplayAlignmentDisplayName(Settings::DEFAULT_DISPLAY_ALIGNMENT)),
     tr("Determines the position on the screen when black borders must be added."));
-  dialog->registerWidgetHelp(m_ui.displayLinearFiltering, tr("Linear Upscaling"), tr("Checked"),
-                             tr("Uses bilinear texture filtering when displaying the console's framebuffer to the "
-                                "screen. <br>Disabling filtering "
-                                "will producer a sharper, blockier/pixelated image. Enabling will smooth out the "
-                                "image. <br>The option will be less "
-                                "noticable the higher the resolution scale."));
   dialog->registerWidgetHelp(
-    m_ui.displayIntegerScaling, tr("Integer Upscaling"), tr("Unchecked"),
-    tr("Adds padding to the display area to ensure that the ratio between pixels on the host to "
-       "pixels in the console is an integer number. <br>May result in a sharper image in some 2D games."));
-  dialog->registerWidgetHelp(m_ui.displayStretch, tr("Stretch To Fill"), tr("Unchecked"),
-                             tr("Fills the window with the active display area, regardless of the aspect ratio."));
+    m_ui.displayScaling, tr("Scaling"), tr("Bilinear (Smooth)"),
+    tr("Determines how the emulated console's output is upscaled or downscaled to your monitor's resolution."));
   dialog->registerWidgetHelp(m_ui.internalResolutionScreenshots, tr("Internal Resolution Screenshots"), tr("Unchecked"),
                              tr("Saves screenshots at internal render resolution and without postprocessing. If this "
                                 "option is disabled, the screenshots will be taken at the window's resolution. "
@@ -177,6 +165,12 @@ void DisplaySettingsWidget::setupAdditionalUi()
       QString::fromUtf8(Settings::GetDisplayCropModeDisplayName(static_cast<DisplayCropMode>(i))));
   }
 
+  for (u32 i = 0; i < static_cast<u32>(DisplayScalingMode::Count); i++)
+  {
+    m_ui.displayScaling->addItem(
+      QString::fromUtf8(Settings::GetDisplayScalingDisplayName(static_cast<DisplayScalingMode>(i))));
+  }
+
   for (u32 i = 0; i < static_cast<u32>(DisplayAlignment::Count); i++)
   {
     m_ui.displayAlignment->addItem(
@@ -289,13 +283,6 @@ void DisplaySettingsWidget::onGPUFullscreenModeIndexChanged()
   m_dialog->setStringSettingValue("GPU", "FullscreenMode", m_ui.fullscreenMode->currentText().toUtf8().constData());
 }
 
-void DisplaySettingsWidget::onIntegerFilteringChanged()
-{
-  const bool integer_scaling = m_dialog->getEffectiveBoolValue("Display", "IntegerScaling", false);
-  m_ui.displayLinearFiltering->setEnabled(!integer_scaling);
-  m_ui.displayStretch->setEnabled(!integer_scaling);
-}
-
 void DisplaySettingsWidget::onAspectRatioChanged()
 {
   const DisplayAspectRatio ratio =

src/duckstation-qt/displaysettingswidget.h

@@ -22,7 +22,6 @@ private Q_SLOTS:
   void populateGPUAdaptersAndResolutions();
   void onGPUAdapterIndexChanged();
   void onGPUFullscreenModeIndexChanged();
-  void onIntegerFilteringChanged();
   void onAspectRatioChanged();
 
 private:

src/duckstation-qt/displaysettingswidget.ui

@@ -154,47 +154,36 @@
       <item row="1" column="1">
        <widget class="QComboBox" name="displayCropMode"/>
       </item>
-      <item row="2" column="0">
+      <item row="3" column="0">
        <widget class="QLabel" name="label_7">
         <property name="text">
          <string>Position:</string>
         </property>
        </widget>
       </item>
-      <item row="2" column="1">
+      <item row="3" column="1">
        <widget class="QComboBox" name="displayAlignment"/>
       </item>
-      <item row="3" column="0" colspan="2">
+      <item row="4" column="0" colspan="2">
        <layout class="QGridLayout" name="gridLayout">
-        <item row="0" column="0">
-         <widget class="QCheckBox" name="displayIntegerScaling">
-          <property name="text">
-           <string>Integer Upscaling</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="1">
-         <widget class="QCheckBox" name="displayStretch">
-          <property name="text">
-           <string>Stretch To Fill</string>
-          </property>
-         </widget>
-        </item>
         <item row="1" column="0">
-         <widget class="QCheckBox" name="displayLinearFiltering">
+         <widget class="QCheckBox" name="internalResolutionScreenshots">
           <property name="text">
-           <string>Linear Upscaling</string>
+           <string>Internal Resolution Screenshots</string>
           </property>
          </widget>
         </item>
-        <item row="1" column="1">
-         <widget class="QCheckBox" name="internalResolutionScreenshots">
+       </layout>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_6">
         <property name="text">
-           <string>Internal Resolution Screenshots</string>
+         <string>Scaling:</string>
         </property>
        </widget>
       </item>
-       </layout>
+      <item row="2" column="1">
+       <widget class="QComboBox" name="displayScaling"/>
       </item>
      </layout>
     </widget>

src/util/gpu_device.cpp

@@ -426,6 +426,7 @@ bool GPUDevice::CreateResources()
   plconfig.rasterization = GPUPipeline::RasterizationState::GetNoCullState();
   plconfig.depth = GPUPipeline::DepthState::GetNoTestsState();
   plconfig.blend = GPUPipeline::BlendState::GetAlphaBlendingState();
+  plconfig.blend.write_mask = 0x7;
   plconfig.color_format = HasSurface() ? m_window_info.surface_format : GPUTexture::Format::RGBA8;
   plconfig.depth_format = GPUTexture::Format::Unknown;
   plconfig.samples = 1;

src/util/shadergen.cpp

@@ -210,7 +210,8 @@ void ShaderGen::WriteHeader(std::stringstream& ss)
     ss << "#define SAMPLE_TEXTURE(name, coords) texture(name, coords)\n";
     ss << "#define SAMPLE_TEXTURE_OFFSET(name, coords, offset) textureOffset(name, coords, offset)\n";
     ss << "#define SAMPLE_TEXTURE_LEVEL(name, coords, level) textureLod(name, coords, level)\n";
-    ss << "#define SAMPLE_TEXTURE_LEVEL_OFFSET(name, coords, level, offset) textureLodOffset(name, coords, level, offset)\n";
+    ss << "#define SAMPLE_TEXTURE_LEVEL_OFFSET(name, coords, level, offset) textureLodOffset(name, coords, level, "
+          "offset)\n";
     ss << "#define LOAD_TEXTURE(name, coords, mip) texelFetch(name, coords, mip)\n";
     ss << "#define LOAD_TEXTURE_MS(name, coords, sample) texelFetch(name, coords, int(sample))\n";
     ss << "#define LOAD_TEXTURE_OFFSET(name, coords, mip, offset) texelFetchOffset(name, coords, mip, offset)\n";
@@ -303,7 +304,6 @@ void ShaderGen::WriteUniformBufferDeclaration(std::stringstream& ss, bool push_c
     ss << "cbuffer UBOBlock : register(b0)\n";
     m_has_uniform_buffer = true;
   }
-
 }
 
 void ShaderGen::DeclareUniformBuffer(std::stringstream& ss, const std::initializer_list<const char*>& members,
@@ -680,44 +680,6 @@ std::string ShaderGen::GenerateCopyFragmentShader()
   return ss.str();
 }
 
-std::string ShaderGen::GenerateDisplayVertexShader()
-{
-  std::stringstream ss;
-  WriteHeader(ss);
-  DeclareUniformBuffer(ss, {"float4 u_src_rect"}, true);
-  DeclareVertexEntryPoint(ss, {}, 0, 1, {}, true);
-  ss << R"(
-{
-  float2 pos = float2(float((v_id << 1) & 2u), float(v_id & 2u));
-  v_tex0 = u_src_rect.xy + pos * u_src_rect.zw;
-  v_pos = float4(pos * float2(2.0f, -2.0f) + float2(-1.0f, 1.0f), 0.0f, 1.0f);
-  #if API_VULKAN
-    v_pos.y = -v_pos.y;
-  #endif
-}
-)";
-
-  return ss.str();
-}
-
-std::string ShaderGen::GenerateDisplayFragmentShader(bool set_alpha_to_one /* = false */)
-{
-  std::stringstream ss;
-  WriteHeader(ss);
-  DeclareTexture(ss, "samp0", 0);
-  DeclareFragmentEntryPoint(ss, 0, 1, {}, false, 1);
-  ss << "{\n";
-
-  if (set_alpha_to_one)
-    ss << "o_col0 = float4(SAMPLE_TEXTURE(samp0, v_tex0).rgb, 1.0f);";
-  else
-    ss << "o_col0 = SAMPLE_TEXTURE(samp0, v_tex0);";
-
-  ss << "\n}\n";
-
-  return ss.str();
-}
-
 std::string ShaderGen::GenerateImGuiVertexShader()
 {
   std::stringstream ss;

src/util/shadergen.h

@@ -20,8 +20,6 @@ public:
   std::string GenerateUVQuadVertexShader();
   std::string GenerateFillFragmentShader();
   std::string GenerateCopyFragmentShader();
-  std::string GenerateDisplayVertexShader();
-  std::string GenerateDisplayFragmentShader(bool set_alpha_to_one = false);
 
   std::string GenerateImGuiVertexShader();
   std::string GenerateImGuiFragmentShader();