Merge pull request #6369 from stenzek/xfb-copy-filter

Implement copy filter (deflickering/brightness) and XFB gamma

Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/ui/settings/SettingsFragmentPresenter.java

@@ -296,8 +296,9 @@ public final class SettingsFragmentPresenter
 		Setting perPixel = mSettings.get(SettingsFile.SETTINGS_GFX).get(SettingsFile.SECTION_GFX_SETTINGS).getSetting(SettingsFile.KEY_PER_PIXEL);
 		Setting forceFilter = mSettings.get(SettingsFile.SETTINGS_GFX).get(SettingsFile.SECTION_GFX_ENHANCEMENTS).getSetting(SettingsFile.KEY_FORCE_FILTERING);
 		Setting disableFog = mSettings.get(SettingsFile.SETTINGS_GFX).get(SettingsFile.SECTION_GFX_SETTINGS).getSetting(SettingsFile.KEY_DISABLE_FOG);
+		Setting disableCopyFilter = mSettings.get(SettingsFile.SETTINGS_GFX).get(SettingsFile.SECTION_GFX_SETTINGS).getSetting(SettingsFile.KEY_DISABLE_COPY_FILTER);
 		Setting shaderCompilationMode = mSettings.get(SettingsFile.SETTINGS_GFX).get(SettingsFile.SECTION_GFX_SETTINGS).getSetting(SettingsFile.KEY_SHADER_COMPILATION_MODE);
-        Setting waitForShaders = mSettings.get(SettingsFile.SETTINGS_GFX).get(SettingsFile.SECTION_GFX_SETTINGS).getSetting(SettingsFile.KEY_WAIT_FOR_SHADERS);
+		Setting waitForShaders = mSettings.get(SettingsFile.SETTINGS_GFX).get(SettingsFile.SECTION_GFX_SETTINGS).getSetting(SettingsFile.KEY_WAIT_FOR_SHADERS);
 
 		sl.add(new SingleChoiceSetting(SettingsFile.KEY_INTERNAL_RES, SettingsFile.SECTION_GFX_SETTINGS, SettingsFile.SETTINGS_GFX, R.string.internal_resolution, R.string.internal_resolution_descrip, R.array.internalResolutionEntries, R.array.internalResolutionValues, 0, resolution));
 		sl.add(new SingleChoiceSetting(SettingsFile.KEY_FSAA, SettingsFile.SECTION_GFX_SETTINGS, SettingsFile.SETTINGS_GFX, R.string.FSAA, R.string.FSAA_descrip, R.array.FSAAEntries, R.array.FSAAValues, 0, fsaa));
@@ -311,6 +312,7 @@ public final class SettingsFragmentPresenter
 		sl.add(new CheckBoxSetting(SettingsFile.KEY_PER_PIXEL, SettingsFile.SECTION_GFX_SETTINGS, SettingsFile.SETTINGS_GFX, R.string.per_pixel_lighting, R.string.per_pixel_lighting_descrip, false, perPixel));
 		sl.add(new CheckBoxSetting(SettingsFile.KEY_FORCE_FILTERING, SettingsFile.SECTION_GFX_ENHANCEMENTS, SettingsFile.SETTINGS_GFX, R.string.force_texture_filtering, R.string.force_texture_filtering_descrip, false, forceFilter));
 		sl.add(new CheckBoxSetting(SettingsFile.KEY_DISABLE_FOG, SettingsFile.SECTION_GFX_SETTINGS, SettingsFile.SETTINGS_GFX, R.string.disable_fog, R.string.disable_fog_descrip, false, disableFog));
+		sl.add(new CheckBoxSetting(SettingsFile.KEY_DISABLE_COPY_FILTER, SettingsFile.SECTION_GFX_SETTINGS, SettingsFile.SETTINGS_GFX, R.string.disable_copy_filter, R.string.disable_copy_filter_descrip, false, disableCopyFilter));
 
 		 /*
 		 Check if we support stereo

Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/utils/SettingsFile.java

@@ -92,6 +92,7 @@ public final class SettingsFile
 	public static final String KEY_PER_PIXEL = "EnablePixelLighting";
 	public static final String KEY_FORCE_FILTERING = "ForceFiltering";
 	public static final String KEY_DISABLE_FOG = "DisableFog";
+	public static final String KEY_DISABLE_COPY_FILTER = "DisableCopyFilter";
 
 	public static final String KEY_STEREO_MODE = "StereoMode";
 	public static final String KEY_STEREO_DEPTH = "StereoDepth";

Source/Android/app/src/main/res/values/strings.xml

@@ -149,6 +149,8 @@
     <string name="force_texture_filtering_descrip">Force texture filtering even if the emulated game explicitly disabled it. Improves texture quality slightly but causes glitches in some games.</string>
     <string name="disable_fog">Disable Fog</string>
     <string name="disable_fog_descrip">Makes distant objects more visible by removing fog, thus increasing the overall detail. Disabling fog will break some games which rely on proper fog emulation.</string>
+    <string name="disable_copy_filter">Disable Copy Filter</string>
+    <string name="disable_copy_filter_descrip">Disables the blending of adjacent rows when copying the EFB. This is known in some games as \"deflickering\" or \"smoothing\". Disabling the filter is usually safe, and may result in a sharper image.</string>
     <string name="stereoscopy">Stereoscopy</string>
     <string name="stereoscopy_descrip">Stereoscopy allows you to get a better feeling of depth if you have the necessary hardware.\nHeavily decreases emulation speed and sometimes causes issues</string>
     <string name="stereoscopy_mode">Stereoscopy Mode</string>

Source/Core/Core/Config/GraphicsSettings.cpp

@@ -106,6 +106,8 @@ const ConfigInfo<std::string> GFX_ENHANCE_POST_SHADER{
     {System::GFX, "Enhancements", "PostProcessingShader"}, ""};
 const ConfigInfo<bool> GFX_ENHANCE_FORCE_TRUE_COLOR{{System::GFX, "Enhancements", "ForceTrueColor"},
                                                     true};
+const ConfigInfo<bool> GFX_ENHANCE_DISABLE_COPY_FILTER{
+    {System::GFX, "Enhancements", "DisableCopyFilter"}, true};
 
 // Graphics.Stereoscopy
 

Source/Core/Core/Config/GraphicsSettings.h

@@ -80,6 +80,7 @@ extern const ConfigInfo<bool> GFX_ENHANCE_FORCE_FILTERING;
 extern const ConfigInfo<int> GFX_ENHANCE_MAX_ANISOTROPY;  // NOTE - this is x in (1 << x)
 extern const ConfigInfo<std::string> GFX_ENHANCE_POST_SHADER;
 extern const ConfigInfo<bool> GFX_ENHANCE_FORCE_TRUE_COLOR;
+extern const ConfigInfo<bool> GFX_ENHANCE_DISABLE_COPY_FILTER;
 
 // Graphics.Stereoscopy
 

Source/Core/Core/ConfigLoaders/IsSettingSaveable.cpp

@@ -85,6 +85,7 @@ bool IsSettingSaveable(const Config::ConfigLocation& config_location)
       Config::GFX_ENHANCE_MAX_ANISOTROPY.location,
       Config::GFX_ENHANCE_POST_SHADER.location,
       Config::GFX_ENHANCE_FORCE_TRUE_COLOR.location,
+      Config::GFX_ENHANCE_DISABLE_COPY_FILTER.location,
 
       // Graphics.Stereoscopy
 

Source/Core/DolphinQt2/Config/Graphics/EnhancementsWidget.cpp

@@ -74,6 +74,8 @@ void EnhancementsWidget::CreateWidgets()
   m_disable_fog = new GraphicsBool(tr("Disable Fog"), Config::GFX_DISABLE_FOG);
   m_force_24bit_color =
       new GraphicsBool(tr("Force 24-Bit Color"), Config::GFX_ENHANCE_FORCE_TRUE_COLOR);
+  m_disable_copy_filter =
+      new GraphicsBool(tr("Disable Copy Filter"), Config::GFX_ENHANCE_DISABLE_COPY_FILTER);
 
   enhancements_layout->addWidget(new QLabel(tr("Internal Resolution:")), 0, 0);
   enhancements_layout->addWidget(m_ir_combo, 0, 1, 1, -1);
@@ -92,6 +94,7 @@ void EnhancementsWidget::CreateWidgets()
   enhancements_layout->addWidget(m_widescreen_hack, 6, 1);
   enhancements_layout->addWidget(m_disable_fog, 7, 0);
   enhancements_layout->addWidget(m_force_24bit_color, 7, 1);
+  enhancements_layout->addWidget(m_disable_copy_filter, 8, 0);
 
   // Stereoscopy
   auto* stereoscopy_box = new QGroupBox(tr("Stereoscopy"));
@@ -269,7 +272,6 @@ void EnhancementsWidget::AddDescriptions()
       QT_TR_NOOP("Makes distant objects more visible by removing fog, thus increasing the overall "
                  "detail.\nDisabling fog will break some games which rely on proper fog "
                  "emulation.\n\nIf unsure, leave this unchecked.");
-
   static const char* TR_3D_MODE_DESCRIPTION = QT_TR_NOOP(
       "Selects the stereoscopic 3D mode. Stereoscopy allows you to get a better feeling "
       "of depth if you have the necessary hardware.\nSide-by-Side and Top-and-Bottom are "
@@ -294,6 +296,11 @@ void EnhancementsWidget::AddDescriptions()
       QT_TR_NOOP("Filter all textures, including any that the game explicitly set as "
                  "unfiltered.\nMay improve quality of certain textures in some games, but will "
                  "cause issues in others.\n\nIf unsure, leave this unchecked.");
+  static const char* TR_DISABLE_COPY_FILTER_DESCRIPTION =
+      QT_TR_NOOP("Disables the blending of adjacent rows when copying the EFB. This is known in "
+                 "some games as \"deflickering\" or \"smoothing\". Disabling the filter has no "
+                 "effect on performance, but may result in a sharper image, and causes few "
+                 "graphical issues.\n\n\nIf unsure, leave this checked.");
 
   AddDescription(m_ir_combo, TR_INTERNAL_RESOLUTION_DESCRIPTION);
   AddDescription(m_aa_combo, TR_ANTIALIAS_DESCRIPTION);
@@ -305,6 +312,7 @@ void EnhancementsWidget::AddDescriptions()
   AddDescription(m_disable_fog, TR_REMOVE_FOG_DESCRIPTION);
   AddDescription(m_force_24bit_color, TR_FORCE_24BIT_DESCRIPTION);
   AddDescription(m_force_texture_filtering, TR_FORCE_TEXTURE_FILTERING_DESCRIPTION);
+  AddDescription(m_disable_copy_filter, TR_DISABLE_COPY_FILTER_DESCRIPTION);
   AddDescription(m_3d_mode, TR_3D_MODE_DESCRIPTION);
   AddDescription(m_3d_depth, TR_3D_DEPTH_DESCRIPTION);
   AddDescription(m_3d_convergence, TR_3D_CONVERGENCE_DESCRIPTION);

Source/Core/DolphinQt2/Config/Graphics/EnhancementsWidget.h

@@ -38,6 +38,7 @@ private:
   QCheckBox* m_widescreen_hack;
   QCheckBox* m_disable_fog;
   QCheckBox* m_force_24bit_color;
+  QCheckBox* m_disable_copy_filter;
 
   // Stereoscopy
   QComboBox* m_3d_mode;

Source/Core/DolphinWX/VideoConfigDiag.cpp

@@ -287,6 +287,11 @@ static wxString true_color_desc =
     wxTRANSLATE("Forces the game to render the RGB color channels in 24-bit, thereby increasing "
                 "quality by reducing color banding.\nIt has no impact on performance and causes "
                 "few graphical issues.\n\n\nIf unsure, leave this checked.");
+static wxString disable_copy_filter_desc =
+    wxTRANSLATE("Disables the blending of adjacent rows when copying the EFB. This is known in "
+                "some games as \"deflickering\" or \"smoothing\". Disabling the filter has no "
+                "effect on performance, but may result in a sharper image, and causes few "
+                "graphical issues.\n\n\nIf unsure, leave this checked.");
 static wxString vertex_rounding_desc =
     wxTRANSLATE("Rounds 2D vertices to whole pixels. Fixes graphical problems in some games at "
                 "higher internal resolutions. This setting has no effect when native internal "
@@ -602,6 +607,9 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string& title)
                                Config::GFX_DISABLE_FOG));
     cb_szr->Add(CreateCheckBox(page_enh, _("Force 24-Bit Color"), wxGetTranslation(true_color_desc),
                                Config::GFX_ENHANCE_FORCE_TRUE_COLOR));
+    cb_szr->Add(CreateCheckBox(page_enh, _("Disable Copy Filter"),
+                               wxGetTranslation(disable_copy_filter_desc),
+                               Config::GFX_ENHANCE_DISABLE_COPY_FILTER));
     szr_enh->Add(cb_szr, wxGBPosition(row, 0), wxGBSpan(1, 3));
     row += 1;
 

Source/Core/VideoBackends/D3D/PSTextureEncoder.cpp

@@ -31,7 +31,11 @@ struct EFBEncodeParams
   u32 DestWidth;
   u32 ScaleFactor;
   float y_scale;
-  u32 padding[3];
+  float gamma_rcp;
+  float clamp_top;
+  float clamp_bottom;
+  s32 filter_coefficients[3];
+  u32 padding;
 };
 
 PSTextureEncoder::PSTextureEncoder()
@@ -66,9 +70,11 @@ void PSTextureEncoder::Shutdown()
   SAFE_RELEASE(m_encode_params);
 }
 
-void PSTextureEncoder::Encode(u8* dst, const EFBCopyParams& params, u32 native_width,
-                              u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
-                              const EFBRectangle& src_rect, bool scale_by_half)
+void PSTextureEncoder::Encode(
+    u8* dst, const EFBCopyParams& params, u32 native_width, u32 bytes_per_row, u32 num_blocks_y,
+    u32 memory_stride, const EFBRectangle& src_rect, bool scale_by_half, float y_scale, float gamma,
+    bool clamp_top, bool clamp_bottom,
+    const TextureCacheBase::CopyFilterCoefficientArray& filter_coefficients)
 {
   // Resolve MSAA targets before copying.
   // FIXME: Instead of resolving EFB, it would be better to pick out a
@@ -101,7 +107,13 @@ void PSTextureEncoder::Encode(u8* dst, const EFBCopyParams& params, u32 native_w
     encode_params.SrcTop = src_rect.top;
     encode_params.DestWidth = native_width;
     encode_params.ScaleFactor = scale_by_half ? 2 : 1;
-    encode_params.y_scale = params.y_scale;
+    encode_params.y_scale = y_scale;
+    encode_params.gamma_rcp = 1.0f / gamma;
+    encode_params.clamp_top = clamp_top ? src_rect.top / float(EFB_HEIGHT) : 0.0f;
+    encode_params.clamp_bottom = clamp_bottom ? src_rect.bottom / float(EFB_HEIGHT) : 0.0f;
+    for (size_t i = 0; i < filter_coefficients.size(); i++)
+      encode_params.filter_coefficients[i] = filter_coefficients[i];
+
     D3D::context->UpdateSubresource(m_encode_params, 0, nullptr, &encode_params, 0, 0);
     D3D::stateman->SetPixelConstants(m_encode_params);
 
@@ -109,7 +121,7 @@ void PSTextureEncoder::Encode(u8* dst, const EFBCopyParams& params, u32 native_w
     // TODO: This only produces perfect downsampling for 2x IR, other resolutions will need more
     //       complex down filtering to average all pixels and produce the correct result.
     // Also, box filtering won't be correct for anything other than 1x IR
-    if (scale_by_half || g_renderer->GetEFBScale() != 1 || params.y_scale > 1.0f)
+    if (scale_by_half || g_renderer->GetEFBScale() != 1 || y_scale > 1.0f)
       D3D::SetLinearCopySampler();
     else
       D3D::SetPointCopySampler();

Source/Core/VideoBackends/D3D/PSTextureEncoder.h

@@ -8,6 +8,7 @@
 #include <memory>
 
 #include "Common/CommonTypes.h"
+#include "VideoCommon/TextureCacheBase.h"
 #include "VideoCommon/TextureConversionShader.h"
 #include "VideoCommon/VideoCommon.h"
 
@@ -38,8 +39,9 @@ public:
   void Init();
   void Shutdown();
   void Encode(u8* dst, const EFBCopyParams& params, u32 native_width, u32 bytes_per_row,
-              u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
-              bool scale_by_half);
+              u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect, bool scale_by_half,
+              float y_scale, float gamma, bool clamp_top, bool clamp_bottom,
+              const TextureCacheBase::CopyFilterCoefficientArray& filter_coefficients);
 
 private:
   ID3D11PixelShader* GetEncodingPixelShader(const EFBCopyParams& params);

Source/Core/VideoBackends/D3D/Render.cpp

@@ -627,8 +627,7 @@ void Renderer::ReinterpretPixelData(unsigned int convtype)
 }
 
 // This function has the final picture. We adjust the aspect ratio here.
-void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region, u64 ticks,
-                        float Gamma)
+void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region, u64 ticks)
 {
   ResetAPIState();
 
@@ -650,7 +649,7 @@ void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region
   auto* xfb_texture = static_cast<DXTexture*>(texture);
 
   BlitScreen(xfb_region, targetRc, xfb_texture->GetRawTexIdentifier(),
-             xfb_texture->GetConfig().width, xfb_texture->GetConfig().height, Gamma);
+             xfb_texture->GetConfig().width, xfb_texture->GetConfig().height);
 
   // Reset viewport for drawing text
   D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.0f, 0.0f, static_cast<float>(m_backbuffer_width),
@@ -854,7 +853,7 @@ void Renderer::BBoxWrite(int index, u16 _value)
 }
 
 void Renderer::BlitScreen(TargetRectangle src, TargetRectangle dst, D3DTexture2D* src_texture,
-                          u32 src_width, u32 src_height, float Gamma)
+                          u32 src_width, u32 src_height)
 {
   if (g_ActiveConfig.stereo_mode == StereoMode::SBS ||
       g_ActiveConfig.stereo_mode == StereoMode::TAB)
@@ -871,13 +870,13 @@ void Renderer::BlitScreen(TargetRectangle src, TargetRectangle dst, D3DTexture2D
     D3D::drawShadedTexQuad(src_texture->GetSRV(), src.AsRECT(), src_width, src_height,
                            PixelShaderCache::GetColorCopyProgram(false),
                            VertexShaderCache::GetSimpleVertexShader(),
-                           VertexShaderCache::GetSimpleInputLayout(), nullptr, Gamma, 0);
+                           VertexShaderCache::GetSimpleInputLayout(), nullptr, 1.0f, 0);
 
     D3D::context->RSSetViewports(1, &rightVp);
     D3D::drawShadedTexQuad(src_texture->GetSRV(), src.AsRECT(), src_width, src_height,
                            PixelShaderCache::GetColorCopyProgram(false),
                            VertexShaderCache::GetSimpleVertexShader(),
-                           VertexShaderCache::GetSimpleInputLayout(), nullptr, Gamma, 1);
+                           VertexShaderCache::GetSimpleInputLayout(), nullptr, 1.0f, 1);
   }
   else if (g_ActiveConfig.stereo_mode == StereoMode::Nvidia3DVision)
   {
@@ -896,13 +895,13 @@ void Renderer::BlitScreen(TargetRectangle src, TargetRectangle dst, D3DTexture2D
     D3D::drawShadedTexQuad(src_texture->GetSRV(), src.AsRECT(), src_width, src_height,
                            PixelShaderCache::GetColorCopyProgram(false),
                            VertexShaderCache::GetSimpleVertexShader(),
-                           VertexShaderCache::GetSimpleInputLayout(), nullptr, Gamma, 0);
+                           VertexShaderCache::GetSimpleInputLayout(), nullptr, 1.0f, 0);
 
     D3D::context->RSSetViewports(1, &rightVp);
     D3D::drawShadedTexQuad(src_texture->GetSRV(), src.AsRECT(), src_width, src_height,
                            PixelShaderCache::GetColorCopyProgram(false),
                            VertexShaderCache::GetSimpleVertexShader(),
-                           VertexShaderCache::GetSimpleInputLayout(), nullptr, Gamma, 1);
+                           VertexShaderCache::GetSimpleInputLayout(), nullptr, 1.0f, 1);
 
     // Copy the left eye to the backbuffer, if Nvidia 3D Vision is enabled it should
     // recognize the signature and automatically include the right eye frame.
@@ -927,7 +926,7 @@ void Renderer::BlitScreen(TargetRectangle src, TargetRectangle dst, D3DTexture2D
                                            nullptr;
     D3D::drawShadedTexQuad(src_texture->GetSRV(), src.AsRECT(), src_width, src_height, pixelShader,
                            VertexShaderCache::GetSimpleVertexShader(),
-                           VertexShaderCache::GetSimpleInputLayout(), geomShader, Gamma);
+                           VertexShaderCache::GetSimpleInputLayout(), geomShader, 1.0f);
   }
 }
 

Source/Core/VideoBackends/D3D/Render.h

@@ -63,7 +63,7 @@ public:
 
   TargetRectangle ConvertEFBRectangle(const EFBRectangle& rc) override;
 
-  void SwapImpl(AbstractTexture* texture, const EFBRectangle& rc, u64 ticks, float Gamma) override;
+  void SwapImpl(AbstractTexture* texture, const EFBRectangle& rc, u64 ticks) override;
 
   void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
                    u32 color, u32 z) override;
@@ -84,7 +84,7 @@ private:
   void UpdateBackbufferSize();
 
   void BlitScreen(TargetRectangle src, TargetRectangle dst, D3DTexture2D* src_texture,
-                  u32 src_width, u32 src_height, float Gamma);
+                  u32 src_width, u32 src_height);
 
   void UpdateUtilityUniformBuffer(const void* uniforms, u32 uniforms_size);
   void UpdateUtilityVertexBuffer(const void* vertices, u32 vertex_stride, u32 num_vertices);

Source/Core/VideoBackends/D3D/TextureCache.cpp

@@ -33,10 +33,12 @@ static std::unique_ptr<PSTextureEncoder> g_encoder;
 
 void TextureCache::CopyEFB(u8* dst, const EFBCopyParams& params, u32 native_width,
                            u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
-                           const EFBRectangle& src_rect, bool scale_by_half)
+                           const EFBRectangle& src_rect, bool scale_by_half, float y_scale,
+                           float gamma, bool clamp_top, bool clamp_bottom,
+                           const CopyFilterCoefficientArray& filter_coefficients)
 {
   g_encoder->Encode(dst, params, native_width, bytes_per_row, num_blocks_y, memory_stride, src_rect,
-                    scale_by_half);
+                    scale_by_half, y_scale, gamma, clamp_top, clamp_bottom, filter_coefficients);
 }
 
 const char palette_shader[] =
@@ -137,9 +139,9 @@ void TextureCache::ConvertTexture(TCacheEntry* destination, TCacheEntry* source,
   D3D::stateman->SetTexture(1, palette_buf_srv);
 
   // TODO: Add support for C14X2 format.  (Different multiplier, more palette entries.)
-  float params[4] = {source->format == TextureFormat::I4 ? 15.f : 255.f};
-  D3D::context->UpdateSubresource(palette_uniform, 0, nullptr, &params, 0, 0);
-  D3D::stateman->SetPixelConstants(palette_uniform);
+  float params[8] = {source->format == TextureFormat::I4 ? 15.f : 255.f};
+  D3D::context->UpdateSubresource(uniform_buffer, 0, nullptr, &params, 0, 0);
+  D3D::stateman->SetPixelConstants(uniform_buffer);
 
   const D3D11_RECT sourcerect = CD3D11_RECT(0, 0, source->GetWidth(), source->GetHeight());
 
@@ -180,7 +182,7 @@ TextureCache::TextureCache()
 
   palette_buf = nullptr;
   palette_buf_srv = nullptr;
-  palette_uniform = nullptr;
+  uniform_buffer = nullptr;
   palette_pixel_shader[static_cast<int>(TLUTFormat::IA8)] = GetConvertShader("IA8");
   palette_pixel_shader[static_cast<int>(TLUTFormat::RGB565)] = GetConvertShader("RGB565");
   palette_pixel_shader[static_cast<int>(TLUTFormat::RGB5A3)] = GetConvertShader("RGB5A3");
@@ -195,10 +197,10 @@ TextureCache::TextureCache()
   CHECK(SUCCEEDED(hr), "create palette decoder lut srv");
   D3D::SetDebugObjectName(palette_buf_srv, "texture decoder lut srv");
   const D3D11_BUFFER_DESC cbdesc =
-      CD3D11_BUFFER_DESC(16, D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DEFAULT);
-  hr = D3D::device->CreateBuffer(&cbdesc, nullptr, &palette_uniform);
+      CD3D11_BUFFER_DESC(sizeof(float) * 8, D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DEFAULT);
+  hr = D3D::device->CreateBuffer(&cbdesc, nullptr, &uniform_buffer);
   CHECK(SUCCEEDED(hr), "Create palette decoder constant buffer");
-  D3D::SetDebugObjectName(palette_uniform,
+  D3D::SetDebugObjectName(uniform_buffer,
                           "a constant buffer used in TextureCache::CopyRenderTargetToTexture");
 }
 
@@ -209,7 +211,7 @@ TextureCache::~TextureCache()
 
   SAFE_RELEASE(palette_buf);
   SAFE_RELEASE(palette_buf_srv);
-  SAFE_RELEASE(palette_uniform);
+  SAFE_RELEASE(uniform_buffer);
   for (auto*& shader : palette_pixel_shader)
     SAFE_RELEASE(shader);
   for (auto& iter : m_efb_to_tex_pixel_shaders)
@@ -218,7 +220,9 @@ TextureCache::~TextureCache()
 
 void TextureCache::CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy,
                                        const EFBRectangle& src_rect, bool scale_by_half,
-                                       EFBCopyFormat dst_format, bool is_intensity)
+                                       EFBCopyFormat dst_format, bool is_intensity, float gamma,
+                                       bool clamp_top, bool clamp_bottom,
+                                       const CopyFilterCoefficientArray& filter_coefficients)
 {
   auto* destination_texture = static_cast<DXTexture*>(entry->texture.get());
 
@@ -260,6 +264,27 @@ void TextureCache::CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy,
   else
     D3D::SetPointCopySampler();
 
+  struct PixelConstants
+  {
+    float filter_coefficients[3];
+    float gamma_rcp;
+    float clamp_top;
+    float clamp_bottom;
+    float pixel_height;
+    u32 padding;
+  };
+  PixelConstants constants;
+  for (size_t i = 0; i < filter_coefficients.size(); i++)
+    constants.filter_coefficients[i] = filter_coefficients[i] / 64.0f;
+  constants.gamma_rcp = 1.0f / gamma;
+  constants.clamp_top = clamp_top ? src_rect.top / float(EFB_HEIGHT) : 0.0f;
+  constants.clamp_bottom = clamp_bottom ? src_rect.bottom / float(EFB_HEIGHT) : 1.0f;
+  constants.pixel_height =
+      g_ActiveConfig.bCopyEFBScaled ? 1.0f / g_renderer->GetTargetHeight() : 1.0f / EFB_HEIGHT;
+  constants.padding = 0;
+  D3D::context->UpdateSubresource(uniform_buffer, 0, nullptr, &constants, 0, 0);
+  D3D::stateman->SetPixelConstants(uniform_buffer);
+
   // Make sure we don't draw with the texture set as both a source and target.
   // (This can happen because we don't unbind textures when we free them.)
   D3D::stateman->UnsetTexture(destination_texture->GetRawTexIdentifier()->GetSRV());

Source/Core/VideoBackends/D3D/TextureCache.h

@@ -34,11 +34,13 @@ private:
 
   void CopyEFB(u8* dst, const EFBCopyParams& params, u32 native_width, u32 bytes_per_row,
                u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
-               bool scale_by_half) override;
+               bool scale_by_half, float y_scale, float gamma, bool clamp_top, bool clamp_bottom,
+               const CopyFilterCoefficientArray& filter_coefficients) override;
 
   void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy, const EFBRectangle& src_rect,
-                           bool scale_by_half, EFBCopyFormat dst_format,
-                           bool is_intensity) override;
+                           bool scale_by_half, EFBCopyFormat dst_format, bool is_intensity,
+                           float gamma, bool clamp_top, bool clamp_bottom,
+                           const CopyFilterCoefficientArray& filter_coefficients) override;
 
   bool CompileShaders() override { return true; }
   void DeleteShaders() override {}
@@ -46,7 +48,7 @@ private:
 
   ID3D11Buffer* palette_buf;
   ID3D11ShaderResourceView* palette_buf_srv;
-  ID3D11Buffer* palette_uniform;
+  ID3D11Buffer* uniform_buffer;
   ID3D11PixelShader* palette_pixel_shader[3];
 
   std::map<TextureConversionShaderGen::TCShaderUid, ID3D11PixelShader*> m_efb_to_tex_pixel_shaders;

Source/Core/VideoBackends/Null/Render.cpp

@@ -92,7 +92,7 @@ TargetRectangle Renderer::ConvertEFBRectangle(const EFBRectangle& rc)
   return result;
 }
 
-void Renderer::SwapImpl(AbstractTexture*, const EFBRectangle&, u64, float)
+void Renderer::SwapImpl(AbstractTexture*, const EFBRectangle&, u64)
 {
   UpdateActiveConfig();
 }

Source/Core/VideoBackends/Null/Render.h

@@ -34,7 +34,7 @@ public:
   void BBoxWrite(int index, u16 value) override {}
   TargetRectangle ConvertEFBRectangle(const EFBRectangle& rc) override;
 
-  void SwapImpl(AbstractTexture* texture, const EFBRectangle& rc, u64 ticks, float Gamma) override;
+  void SwapImpl(AbstractTexture* texture, const EFBRectangle& rc, u64 ticks) override;
 
   void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
                    u32 color, u32 z) override

Source/Core/VideoBackends/Null/TextureCache.h

@@ -27,12 +27,15 @@ public:
 
   void CopyEFB(u8* dst, const EFBCopyParams& params, u32 native_width, u32 bytes_per_row,
                u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
-               bool scale_by_half) override
+               bool scale_by_half, float y_scale, float gamma, bool clamp_top, bool clamp_bottom,
+               const CopyFilterCoefficientArray& filter_coefficients) override
   {
   }
 
   void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy, const EFBRectangle& src_rect,
-                           bool scale_by_half, EFBCopyFormat dst_format, bool is_intensity) override
+                           bool scale_by_half, EFBCopyFormat dst_format, bool is_intensity,
+                           float gamma, bool clamp_top, bool clamp_bottom,
+                           const CopyFilterCoefficientArray& filter_coefficients) override
   {
   }
 };

Source/Core/VideoBackends/OGL/Render.cpp

@@ -1365,8 +1365,7 @@ void Renderer::ApplyBlendingState(const BlendingState state, bool force)
 }
 
 // This function has the final picture. We adjust the aspect ratio here.
-void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region, u64 ticks,
-                        float Gamma)
+void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region, u64 ticks)
 {
   if (g_ogl_config.bSupportsDebug)
   {

Source/Core/VideoBackends/OGL/Render.h

@@ -126,7 +126,7 @@ public:
 
   TargetRectangle ConvertEFBRectangle(const EFBRectangle& rc) override;
 
-  void SwapImpl(AbstractTexture* texture, const EFBRectangle& rc, u64 ticks, float Gamma) override;
+  void SwapImpl(AbstractTexture* texture, const EFBRectangle& rc, u64 ticks) override;
 
   void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
                    u32 color, u32 z) override;