Add area sampling scaler to allow for super-sampled anti-aliasing.

src/Ryujinx.Graphics.GAL/UpscaleType.cs

@@ -5,5 +5,6 @@ namespace Ryujinx.Graphics.GAL
         Bilinear,
         Nearest,
         Fsr,
+        Area,
     }
 }

src/Ryujinx.Graphics.OpenGL/Effects/AreaScalingFilter.cs

@@ -0,0 +1,124 @@
+using OpenTK.Graphics.OpenGL;
+using Ryujinx.Common;
+using Ryujinx.Graphics.GAL;
+using Ryujinx.Graphics.OpenGL.Image;
+using System;
+using static Ryujinx.Graphics.OpenGL.Effects.ShaderHelper;
+
+namespace Ryujinx.Graphics.OpenGL.Effects
+{
+    internal class AreaScalingFilter : IScalingFilter
+    {
+        private readonly OpenGLRenderer _renderer;
+        private int _inputUniform;
+        private int _outputUniform;
+        private int _srcX0Uniform;
+        private int _srcX1Uniform;
+        private int _srcY0Uniform;
+        private int _scalingShaderProgram;
+        private float _scale = 1;
+        private int _srcY1Uniform;
+        private int _dstX0Uniform;
+        private int _dstX1Uniform;
+        private int _dstY0Uniform;
+        private int _dstY1Uniform;
+        private int _scaleXUniform;
+        private int _scaleYUniform;
+
+        public float Level
+        {
+            get => _scale;
+            set
+            {
+                _scale = MathF.Max(0.01f, value);
+            }
+        }
+
+        public AreaScalingFilter(OpenGLRenderer renderer)
+        {
+            Initialize();
+
+            _renderer = renderer;
+        }
+
+        public void Dispose()
+        {
+            if (_scalingShaderProgram != 0)
+            {
+                GL.DeleteProgram(_scalingShaderProgram);
+            }
+        }
+
+        private void Initialize()
+        {
+            var scalingShader = EmbeddedResources.ReadAllText("Ryujinx.Graphics.OpenGL/Effects/Shaders/area_scaling.glsl");
+
+            _scalingShaderProgram = CompileProgram(scalingShader, ShaderType.ComputeShader);
+
+            _inputUniform = GL.GetUniformLocation(_scalingShaderProgram, "Source");
+            _outputUniform = GL.GetUniformLocation(_scalingShaderProgram, "imgOutput");
+
+            _srcX0Uniform = GL.GetUniformLocation(_scalingShaderProgram, "srcX0");
+            _srcX1Uniform = GL.GetUniformLocation(_scalingShaderProgram, "srcX1");
+            _srcY0Uniform = GL.GetUniformLocation(_scalingShaderProgram, "srcY0");
+            _srcY1Uniform = GL.GetUniformLocation(_scalingShaderProgram, "srcY1");
+            _dstX0Uniform = GL.GetUniformLocation(_scalingShaderProgram, "dstX0");
+            _dstX1Uniform = GL.GetUniformLocation(_scalingShaderProgram, "dstX1");
+            _dstY0Uniform = GL.GetUniformLocation(_scalingShaderProgram, "dstY0");
+            _dstY1Uniform = GL.GetUniformLocation(_scalingShaderProgram, "dstY1");
+            _scaleXUniform = GL.GetUniformLocation(_scalingShaderProgram, "scaleX");
+            _scaleYUniform = GL.GetUniformLocation(_scalingShaderProgram, "scaleY");
+        }
+
+        public void Run(
+            TextureView view,
+            TextureView destinationTexture,
+            int width,
+            int height,
+            Extents2D source,
+            Extents2D destination)
+        {
+            int previousProgram = GL.GetInteger(GetPName.CurrentProgram);
+            int previousUnit = GL.GetInteger(GetPName.ActiveTexture);
+            GL.ActiveTexture(TextureUnit.Texture0);
+            int previousTextureBinding = GL.GetInteger(GetPName.TextureBinding2D);
+
+            GL.BindImageTexture(0, destinationTexture.Handle, 0, false, 0, TextureAccess.ReadWrite, SizedInternalFormat.Rgba8);
+
+            int threadGroupWorkRegionDim = 16;
+            int dispatchX = (width + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchY = (height + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+
+            // Scaling pass
+            float srcWidth = Math.Abs(source.X2 - source.X1);
+            float srcHeight = Math.Abs(source.Y2 - source.Y1);
+            float scaleX = srcWidth / view.Width;
+            float scaleY = srcHeight / view.Height;
+            GL.UseProgram(_scalingShaderProgram);
+            view.Bind(0);
+            GL.Uniform1(_inputUniform, 0);
+            GL.Uniform1(_outputUniform, 0);
+            GL.Uniform1(_srcX0Uniform, (float)source.X1);
+            GL.Uniform1(_srcX1Uniform, (float)source.X2);
+            GL.Uniform1(_srcY0Uniform, (float)source.Y1);
+            GL.Uniform1(_srcY1Uniform, (float)source.Y2);
+            GL.Uniform1(_dstX0Uniform, (float)destination.X1);
+            GL.Uniform1(_dstX1Uniform, (float)destination.X2);
+            GL.Uniform1(_dstY0Uniform, (float)destination.Y1);
+            GL.Uniform1(_dstY1Uniform, (float)destination.Y2);
+            GL.Uniform1(_scaleXUniform, scaleX);
+            GL.Uniform1(_scaleYUniform, scaleY);
+            GL.DispatchCompute(dispatchX, dispatchY, 1);
+
+            GL.UseProgram(previousProgram);
+            GL.MemoryBarrier(MemoryBarrierFlags.ShaderImageAccessBarrierBit);
+
+            (_renderer.Pipeline as Pipeline).RestoreImages1And2();
+
+            GL.ActiveTexture(TextureUnit.Texture0);
+            GL.BindTexture(TextureTarget.Texture2D, previousTextureBinding);
+
+            GL.ActiveTexture((TextureUnit)previousUnit);
+        }
+    }
+}

src/Ryujinx.Graphics.OpenGL/Effects/ShaderHelper.cs

@@ -1,4 +1,5 @@
 using OpenTK.Graphics.OpenGL;
+using Ryujinx.Common.Logging;
 
 namespace Ryujinx.Graphics.OpenGL.Effects
 {
@@ -10,6 +11,15 @@ namespace Ryujinx.Graphics.OpenGL.Effects
             GL.ShaderSource(shader, shaderCode);
             GL.CompileShader(shader);
 
+            GL.GetShader(shader, ShaderParameter.CompileStatus, out int isCompiled);
+            if (isCompiled == 0)
+            {
+                string log = GL.GetShaderInfoLog(shader);
+                Logger.Error?.Print(LogClass.Gpu, $"Failed to compile effect shader:\n\n{log}\n");
+                GL.DeleteShader(shader);
+                return 0;
+            }
+
             var program = GL.CreateProgram();
             GL.AttachShader(program, shader);
             GL.LinkProgram(program);
@@ -26,6 +36,15 @@ namespace Ryujinx.Graphics.OpenGL.Effects
             GL.ShaderSource(shader, shaders.Length, shaders, (int[])null);
             GL.CompileShader(shader);
 
+            GL.GetShader(shader, ShaderParameter.CompileStatus, out int isCompiled);
+            if (isCompiled == 0)
+            {
+                string log = GL.GetShaderInfoLog(shader);
+                Logger.Error?.Print(LogClass.Gpu, $"Failed to compile effect shader:\n\n{log}\n");
+                GL.DeleteShader(shader);
+                return 0;
+            }
+
             var program = GL.CreateProgram();
             GL.AttachShader(program, shader);
             GL.LinkProgram(program);

src/Ryujinx.Graphics.OpenGL/Effects/Shaders/area_scaling.glsl

@@ -0,0 +1,171 @@
+#version 430 core
+precision mediump float;
+layout (local_size_x = 16, local_size_y = 16) in;
+layout(rgba8, binding = 0, location=0) uniform image2D imgOutput;
+layout( location=1 ) uniform sampler2D Source;
+layout( location=2 ) uniform float srcX0;
+layout( location=3 ) uniform float srcX1;
+layout( location=4 ) uniform float srcY0;
+layout( location=5 ) uniform float srcY1;
+layout( location=6 ) uniform float dstX0;
+layout( location=7 ) uniform float dstX1;
+layout( location=8 ) uniform float dstY0;
+layout( location=9 ) uniform float dstY1;
+layout( location=10 ) uniform float scaleX;
+layout( location=11 ) uniform float scaleY;
+
+vec2 GetResolution()
+{
+    return vec2(abs(srcX1 - srcX0), abs(srcY1 - srcY0));
+}
+
+vec2 GetInvResolution()
+{
+    return vec2(1.0) / GetResolution();
+}
+
+vec2 GetWindowResolution()
+{
+    return vec2(abs(dstX1 - dstX0), abs(dstY1 - dstY0));
+}
+
+vec2 GetInvWindowResolution()
+{
+    return vec2(1.0) / GetWindowResolution();
+}
+
+/***** COLOR SAMPLING *****/
+
+// Non filtered sample (nearest neighbor)
+vec4 QuickSample(vec2 uv)
+{
+#if 0 // Test sampling range
+	const float threshold = 0.00000001;
+    vec2 xy = uv.xy * GetResolution();
+	// Sampling outside the valid range, draw in yellow
+	if (xy.x < (srcX0 - threshold) || xy.x > (srcX1 + threshold) || xy.y < (srcY0 - threshold) || xy.y > (srcY1 + threshold))
+		return vec4(1.0, 1.0, 0.0, 1);
+	// Sampling at the edges, draw in purple
+	if (xy.x < srcX0 + 1.0 || xy.x > (srcX1 - 1.0) || xy.y < srcY0 + 1.0 || xy.y > (srcY1 - 1.0))
+		return vec4(0.5, 0, 0.5, 1);
+#endif
+	return texture(Source, uv);
+}
+vec4 QuickSampleByPixel(vec2 xy)
+{
+	vec2 uv = vec2(xy * GetInvResolution());
+	return QuickSample(uv);
+}
+
+/***** Area Sampling *****/
+
+// By Sam Belliveau and Filippo Tarpini. Public Domain license.
+// Effectively a more accurate sharp bilinear filter when upscaling,
+// that also works as a mathematically perfect downscale filter.
+// https://entropymine.com/imageworsener/pixelmixing/
+// https://github.com/obsproject/obs-studio/pull/1715
+// https://legacy.imagemagick.org/Usage/filter/
+vec4 AreaSampling(vec2 xy)
+{
+	// Determine the sizes of the source and target images.
+    vec2 source_size = GetResolution();
+    vec2 target_size = GetWindowResolution();
+    vec2 inverted_target_size = GetInvWindowResolution();
+
+	// Compute the top-left and bottom-right corners of the target pixel box.
+    vec2 t_beg = floor(xy - vec2(dstX0 < dstX1 ? dstX0 : dstX1, dstY0 < dstY1 ? dstY0 : dstY1));
+    vec2 t_end = t_beg + vec2(1.0, 1.0);
+
+	// Convert the target pixel box to source pixel box.
+    vec2 beg = t_beg * inverted_target_size * source_size;
+    vec2 end = t_end * inverted_target_size * source_size;
+
+	// Compute the top-left and bottom-right corners of the pixel box.
+    vec2 f_beg = floor(beg);
+    vec2 f_end = floor(end);
+
+	// Compute how much of the start and end pixels are covered horizontally & vertically.
+	float area_w = 1.0 - fract(beg.x);
+	float area_n = 1.0 - fract(beg.y);
+	float area_e = fract(end.x);
+	float area_s = fract(end.y);
+
+	// Compute the areas of the corner pixels in the pixel box.
+	float area_nw = area_n * area_w;
+	float area_ne = area_n * area_e;
+	float area_sw = area_s * area_w;
+	float area_se = area_s * area_e;
+
+	// Initialize the color accumulator.
+	vec4 avg_color = vec4(0.0, 0.0, 0.0, 0.0);
+
+	// Prevents rounding errors due to the coordinates flooring above
+	const vec2 offset = vec2(0.5, 0.5);
+
+	// Accumulate corner pixels.
+	avg_color += area_nw * QuickSampleByPixel(vec2(f_beg.x, f_beg.y) + offset);
+	avg_color += area_ne * QuickSampleByPixel(vec2(f_end.x, f_beg.y) + offset);
+	avg_color += area_sw * QuickSampleByPixel(vec2(f_beg.x, f_end.y) + offset);
+	avg_color += area_se * QuickSampleByPixel(vec2(f_end.x, f_end.y) + offset);
+
+	// Determine the size of the pixel box.
+	int x_range = int(f_end.x - f_beg.x - 0.5);
+	int y_range = int(f_end.y - f_beg.y - 0.5);
+
+	// Accumulate top and bottom edge pixels.
+	for (int ix = 0; ix < x_range; ++ix)
+	{
+		float x = f_beg.x + 1.0 + float(ix);
+		avg_color += area_n * QuickSampleByPixel(vec2(x, f_beg.y) + offset);
+		avg_color += area_s * QuickSampleByPixel(vec2(x, f_end.y) + offset);
+	}
+
+	// Accumulate left and right edge pixels and all the pixels in between.
+	for (int iy = 0; iy < y_range; ++iy)
+	{
+		float y = f_beg.y + 1.0 + float(iy);
+
+		avg_color += area_w * QuickSampleByPixel(vec2(f_beg.x, y) + offset);
+		avg_color += area_e * QuickSampleByPixel(vec2(f_end.x, y) + offset);
+
+		for (int ix = 0; ix < x_range; ++ix)
+		{
+			float x = f_beg.x + 1.0 + float(ix);
+			avg_color += QuickSampleByPixel(vec2(x, y) + offset);
+		}
+	}
+
+	// Compute the area of the pixel box that was sampled.
+	float area_corners = area_nw + area_ne + area_sw + area_se;
+	float area_edges = float(x_range) * (area_n + area_s) + float(y_range) * (area_w + area_e);
+	float area_center = float(x_range) * float(y_range);
+
+	// Return the normalized average color.
+	return avg_color / (area_corners + area_edges + area_center);
+}
+
+float insideBox(vec2 v, vec2 bLeft, vec2 tRight) {
+    vec2 s = step(bLeft, v) - step(tRight, v);
+    return s.x * s.y;
+}
+
+vec2 translateDest(vec2 pos) {
+    vec2 translatedPos = vec2(pos.x, pos.y);
+    translatedPos.x = dstX1 < dstX0 ? dstX1 - translatedPos.x : translatedPos.x;
+    translatedPos.y = dstY0 > dstY1 ? dstY0 + dstY1 - translatedPos.y - 1 : translatedPos.y;
+    return translatedPos;
+}
+
+void main()
+{
+    vec2 bLeft = vec2(dstX0 < dstX1 ? dstX0 : dstX1, dstY0 < dstY1 ? dstY0 : dstY1);
+    vec2 tRight = vec2(dstX1 > dstX0 ? dstX1 : dstX0, dstY1 > dstY0 ? dstY1 : dstY0);
+    ivec2 loc = ivec2(gl_GlobalInvocationID.x, gl_GlobalInvocationID.y);
+    if (insideBox(loc, bLeft, tRight) == 0) {
+        imageStore(imgOutput, loc, vec4(0, 0, 0, 1));
+        return;
+    }
+
+    vec4 outColor = AreaSampling(loc);
+    imageStore(imgOutput, ivec2(translateDest(loc)), outColor);
+}

src/Ryujinx.Graphics.OpenGL/Effects/Shaders/fsr_scaling.glsl

@@ -85,4 +85,4 @@ void main() {
     CurrFilter(gxy);
     gxy.x -= 8u;
     CurrFilter(gxy);
-}
+}

src/Ryujinx.Graphics.OpenGL/Ryujinx.Graphics.OpenGL.csproj

@@ -5,11 +5,16 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
+  <ItemGroup>
+    <None Remove="Effects\Shaders\area_scaling.glsl" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="OpenTK.Graphics" />
   </ItemGroup>
 
   <ItemGroup>
+    <EmbeddedResource Include="Effects\Shaders\area_scaling.glsl" />
     <EmbeddedResource Include="Effects\Textures\SmaaAreaTexture.bin" />
     <EmbeddedResource Include="Effects\Textures\SmaaSearchTexture.bin" />
     <EmbeddedResource Include="Effects\Shaders\fsr_sharpening.glsl" />

src/Ryujinx.Graphics.OpenGL/Window.cs

@@ -373,6 +373,17 @@ namespace Ryujinx.Graphics.OpenGL
                         _isLinear = false;
                         _scalingFilter.Level = _scalingFilterLevel;
 
+                        RecreateUpscalingTexture();
+                        break;
+                    case ScalingFilter.Area:
+                        if (_scalingFilter is not AreaScalingFilter)
+                        {
+                            _scalingFilter?.Dispose();
+                            _scalingFilter = new AreaScalingFilter(_renderer);
+                        }
+                        _isLinear = false;
+                        _scalingFilter.Level = _scalingFilterLevel;
+
                         RecreateUpscalingTexture();
                         break;
                 }

src/Ryujinx.Graphics.Vulkan/Effects/AreaScalingFilter.cs

@@ -0,0 +1,120 @@
+using Ryujinx.Common;
+using Ryujinx.Graphics.GAL;
+using Ryujinx.Graphics.Shader;
+using Ryujinx.Graphics.Shader.Translation;
+using Silk.NET.Vulkan;
+using System;
+using Extent2D = Ryujinx.Graphics.GAL.Extents2D;
+using Format = Silk.NET.Vulkan.Format;
+using SamplerCreateInfo = Ryujinx.Graphics.GAL.SamplerCreateInfo;
+
+namespace Ryujinx.Graphics.Vulkan.Effects
+{
+    internal class AreaScalingFilter : IScalingFilter
+    {
+        private readonly VulkanRenderer _renderer;
+        private PipelineHelperShader _pipeline;
+        private ISampler _sampler;
+        private ShaderCollection _scalingProgram;
+        private float _sharpeningLevel = 1;
+        private Device _device;
+
+        public float Level
+        {
+            get => _sharpeningLevel;
+            set
+            {
+                _sharpeningLevel = MathF.Max(0.01f, value);
+            }
+        }
+
+        public AreaScalingFilter(VulkanRenderer renderer, Device device)
+        {
+            _device = device;
+            _renderer = renderer;
+
+            Initialize();
+        }
+
+        public void Dispose()
+        {
+            _pipeline.Dispose();
+            _scalingProgram.Dispose();
+            _sampler.Dispose();
+        }
+
+        public void Initialize()
+        {
+            _pipeline = new PipelineHelperShader(_renderer, _device);
+
+            _pipeline.Initialize();
+
+            var scalingShader = EmbeddedResources.Read("Ryujinx.Graphics.Vulkan/Effects/Shaders/AreaScaling.spv");
+
+            var scalingResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 2)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 1)
+                .Add(ResourceStages.Compute, ResourceType.Image, 0, true).Build();
+
+            _sampler = _renderer.CreateSampler(SamplerCreateInfo.Create(MinFilter.Linear, MagFilter.Linear));
+
+            _scalingProgram = _renderer.CreateProgramWithMinimalLayout(new[]
+            {
+                new ShaderSource(scalingShader, ShaderStage.Compute, TargetLanguage.Spirv),
+            }, scalingResourceLayout);
+        }
+
+        public void Run(
+            TextureView view,
+            CommandBufferScoped cbs,
+            Auto<DisposableImageView> destinationTexture,
+            Format format,
+            int width,
+            int height,
+            Extent2D source,
+            Extent2D destination)
+        {
+            _pipeline.SetCommandBuffer(cbs);
+            _pipeline.SetProgram(_scalingProgram);
+            _pipeline.SetTextureAndSampler(ShaderStage.Compute, 1, view, _sampler);
+
+            float srcWidth = Math.Abs(source.X2 - source.X1);
+            float srcHeight = Math.Abs(source.Y2 - source.Y1);
+            float scaleX = srcWidth / view.Width;
+            float scaleY = srcHeight / view.Height;
+
+            ReadOnlySpan<float> dimensionsBuffer = stackalloc float[]
+            {
+                source.X1,
+                source.X2,
+                source.Y1,
+                source.Y2,
+                destination.X1,
+                destination.X2,
+                destination.Y1,
+                destination.Y2,
+                scaleX,
+                scaleY,
+            };
+
+            int rangeSize = dimensionsBuffer.Length * sizeof(float);
+            using var buffer = _renderer.BufferManager.ReserveOrCreate(_renderer, cbs, rangeSize);
+            buffer.Holder.SetDataUnchecked(buffer.Offset, dimensionsBuffer);
+
+            ReadOnlySpan<float> sharpeningBufferData = stackalloc float[] { 1.5f - (Level * 0.01f * 1.5f) };
+            using var sharpeningBuffer = _renderer.BufferManager.ReserveOrCreate(_renderer, cbs, sizeof(float));
+            sharpeningBuffer.Holder.SetDataUnchecked(sharpeningBuffer.Offset, sharpeningBufferData);
+
+            int threadGroupWorkRegionDim = 16;
+            int dispatchX = (width + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchY = (height + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+
+            _pipeline.SetUniformBuffers(stackalloc[] { new BufferAssignment(2, buffer.Range) });
+            _pipeline.SetImage(0, destinationTexture);
+            _pipeline.DispatchCompute(dispatchX, dispatchY, 1);
+            _pipeline.ComputeBarrier();
+
+            _pipeline.Finish();
+        }
+    }
+}

src/Ryujinx.Graphics.Vulkan/Effects/Shaders/AreaScaling.glsl

@@ -0,0 +1,174 @@
+// Scaling
+
+#version 430 core
+layout (local_size_x = 16, local_size_y = 16) in;
+layout( rgba8, binding = 0, set = 3) uniform image2D imgOutput;
+layout( binding = 1, set = 2) uniform sampler2D Source;
+layout( binding = 2 ) uniform dimensions{
+ float srcX0;
+ float srcX1;
+ float srcY0;
+ float srcY1;
+ float dstX0;
+ float dstX1;
+ float dstY0;
+ float dstY1;
+ float scaleX;
+ float scaleY;
+};
+
+vec2 GetResolution()
+{
+    return vec2(abs(srcX1 - srcX0), abs(srcY1 - srcY0));
+}
+
+vec2 GetInvResolution()
+{
+    return vec2(1.0) / GetResolution();
+}
+
+vec2 GetWindowResolution()
+{
+    return vec2(abs(dstX1 - dstX0), abs(dstY1 - dstY0));
+}
+
+vec2 GetInvWindowResolution()
+{
+    return vec2(1.0) / GetWindowResolution();
+}
+
+/***** COLOR SAMPLING *****/
+
+// Non filtered sample (nearest neighbor)
+vec4 QuickSample(vec2 uv)
+{
+#if 0 // Test sampling range
+	const float threshold = 0.00000001;
+    vec2 xy = uv.xy * GetResolution();
+	// Sampling outside the valid range, draw in yellow
+	if (xy.x < (srcX0 - threshold) || xy.x > (srcX1 + threshold) || xy.y < (srcY0 - threshold) || xy.y > (srcY1 + threshold))
+		return vec4(1.0, 1.0, 0.0, 1);
+	// Sampling at the edges, draw in purple
+	if (xy.x < srcX0 + 1.0 || xy.x > (srcX1 - 1.0) || xy.y < srcY0 + 1.0 || xy.y > (srcY1 - 1.0))
+		return vec4(0.5, 0, 0.5, 1);
+#endif
+	return texture(Source, uv);
+}
+vec4 QuickSampleByPixel(vec2 xy)
+{
+	vec2 uv = vec2(xy * GetInvResolution());
+	return QuickSample(uv);
+}
+
+/***** Area Sampling *****/
+
+// By Sam Belliveau and Filippo Tarpini. Public Domain license.
+// Effectively a more accurate sharp bilinear filter when upscaling,
+// that also works as a mathematically perfect downscale filter.
+// https://entropymine.com/imageworsener/pixelmixing/
+// https://github.com/obsproject/obs-studio/pull/1715
+// https://legacy.imagemagick.org/Usage/filter/
+vec4 AreaSampling(vec2 xy)
+{
+	// Determine the sizes of the source and target images.
+    vec2 source_size = GetResolution();
+    vec2 target_size = GetWindowResolution();
+    vec2 inverted_target_size = GetInvWindowResolution();
+
+	// Compute the top-left and bottom-right corners of the target pixel box.
+    vec2 t_beg = floor(xy - vec2(dstX0 < dstX1 ? dstX0 : dstX1, dstY0 < dstY1 ? dstY0 : dstY1));
+    vec2 t_end = t_beg + vec2(1.0, 1.0);
+
+	// Convert the target pixel box to source pixel box.
+    vec2 beg = t_beg * inverted_target_size * source_size;
+    vec2 end = t_end * inverted_target_size * source_size;
+
+	// Compute the top-left and bottom-right corners of the pixel box.
+    vec2 f_beg = floor(beg);
+    vec2 f_end = floor(end);
+
+	// Compute how much of the start and end pixels are covered horizontally & vertically.
+	float area_w = 1.0 - fract(beg.x);
+	float area_n = 1.0 - fract(beg.y);
+	float area_e = fract(end.x);
+	float area_s = fract(end.y);
+
+	// Compute the areas of the corner pixels in the pixel box.
+	float area_nw = area_n * area_w;
+	float area_ne = area_n * area_e;
+	float area_sw = area_s * area_w;
+	float area_se = area_s * area_e;
+
+	// Initialize the color accumulator.
+	vec4 avg_color = vec4(0.0, 0.0, 0.0, 0.0);
+
+	// Prevents rounding errors due to the coordinates flooring above
+	const vec2 offset = vec2(0.5, 0.5);
+
+	// Accumulate corner pixels.
+	avg_color += area_nw * QuickSampleByPixel(vec2(f_beg.x, f_beg.y) + offset);
+	avg_color += area_ne * QuickSampleByPixel(vec2(f_end.x, f_beg.y) + offset);
+	avg_color += area_sw * QuickSampleByPixel(vec2(f_beg.x, f_end.y) + offset);
+	avg_color += area_se * QuickSampleByPixel(vec2(f_end.x, f_end.y) + offset);
+
+	// Determine the size of the pixel box.
+	int x_range = int(f_end.x - f_beg.x - 0.5);
+	int y_range = int(f_end.y - f_beg.y - 0.5);
+
+	// Accumulate top and bottom edge pixels.
+	for (int ix = 0; ix < x_range; ++ix)
+	{
+		float x = f_beg.x + 1.0 + float(ix);
+		avg_color += area_n * QuickSampleByPixel(vec2(x, f_beg.y) + offset);
+		avg_color += area_s * QuickSampleByPixel(vec2(x, f_end.y) + offset);
+	}
+
+	// Accumulate left and right edge pixels and all the pixels in between.
+	for (int iy = 0; iy < y_range; ++iy)
+	{
+		float y = f_beg.y + 1.0 + float(iy);
+
+		avg_color += area_w * QuickSampleByPixel(vec2(f_beg.x, y) + offset);
+		avg_color += area_e * QuickSampleByPixel(vec2(f_end.x, y) + offset);
+
+		for (int ix = 0; ix < x_range; ++ix)
+		{
+			float x = f_beg.x + 1.0 + float(ix);
+			avg_color += QuickSampleByPixel(vec2(x, y) + offset);
+		}
+	}
+
+	// Compute the area of the pixel box that was sampled.
+	float area_corners = area_nw + area_ne + area_sw + area_se;
+	float area_edges = float(x_range) * (area_n + area_s) + float(y_range) * (area_w + area_e);
+	float area_center = float(x_range) * float(y_range);
+
+	// Return the normalized average color.
+	return avg_color / (area_corners + area_edges + area_center);
+}
+
+float insideBox(vec2 v, vec2 bLeft, vec2 tRight) {
+    vec2 s = step(bLeft, v) - step(tRight, v);
+    return s.x * s.y;
+}
+
+vec2 translateDest(vec2 pos) {
+    vec2 translatedPos = vec2(pos.x, pos.y);
+    translatedPos.x = dstX1 < dstX0 ? dstX1 - translatedPos.x : translatedPos.x;
+    translatedPos.y = dstY0 < dstY1 ? dstY1 + dstY0 - translatedPos.y - 1 : translatedPos.y;
+    return translatedPos;
+}
+
+void main()
+{
+    vec2 bLeft = vec2(dstX0 < dstX1 ? dstX0 : dstX1, dstY0 < dstY1 ? dstY0 : dstY1);
+    vec2 tRight = vec2(dstX1 > dstX0 ? dstX1 : dstX0, dstY1 > dstY0 ? dstY1 : dstY0);
+    ivec2 loc = ivec2(gl_GlobalInvocationID.x, gl_GlobalInvocationID.y);
+    if (insideBox(loc, bLeft, tRight) == 0) {
+        imageStore(imgOutput, loc, vec4(0, 0, 0, 1));
+        return;
+    }
+
+    vec4 outColor = AreaSampling(loc);
+    imageStore(imgOutput, ivec2(translateDest(loc)), outColor);
+}

src/Ryujinx.Graphics.Vulkan/Ryujinx.Graphics.Vulkan.csproj

@@ -13,6 +13,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <None Remove="Effects\Shaders\AreaScaling.glsl" />
+    <None Remove="Effects\Shaders\AreaScaling.spv" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="Effects\Shaders\AreaScaling.glsl" />
+    <EmbeddedResource Include="Effects\Shaders\AreaScaling.spv" />
     <EmbeddedResource Include="Effects\Textures\SmaaAreaTexture.bin" />
     <EmbeddedResource Include="Effects\Textures\SmaaSearchTexture.bin" />
     <EmbeddedResource Include="Effects\Shaders\FsrScaling.spv" />

src/Ryujinx.Graphics.Vulkan/Window.cs

@@ -566,6 +566,15 @@ namespace Ryujinx.Graphics.Vulkan
                             _scalingFilter = new FsrScalingFilter(_gd, _device);
                         }
 
+                        _scalingFilter.Level = _scalingFilterLevel;
+                        break;
+                    case ScalingFilter.Area:
+                        if (_scalingFilter is not AreaScalingFilter)
+                        {
+                            _scalingFilter?.Dispose();
+                            _scalingFilter = new AreaScalingFilter(_gd, _device);
+                        }
+
                         _scalingFilter.Level = _scalingFilterLevel;
                         break;
                 }

src/Ryujinx/Assets/Locales/en_US.json

@@ -758,10 +758,11 @@
   "GraphicsAATooltip": "Applies anti-aliasing to the game render.\n\nFXAA will blur most of the image, while SMAA will attempt to find jagged edges and smooth them out.\n\nNot recommended to use in conjunction with the FSR scaling filter.\n\nThis option can be changed while a game is running by clicking \"Apply\" below; you can simply move the settings window aside and experiment until you find your preferred look for a game.\n\nLeave on NONE if unsure.",
   "GraphicsAALabel": "Anti-Aliasing:",
   "GraphicsScalingFilterLabel": "Scaling Filter:",
-  "GraphicsScalingFilterTooltip": "Choose the scaling filter that will be applied when using resolution scale.\n\nBilinear works well for 3D games and is a safe default option.\n\nNearest is recommended for pixel art games.\n\nFSR 1.0 is merely a sharpening filter, not recommended for use with FXAA or SMAA.\n\nThis option can be changed while a game is running by clicking \"Apply\" below; you can simply move the settings window aside and experiment until you find your preferred look for a game.\n\nLeave on BILINEAR if unsure.",
+  "GraphicsScalingFilterTooltip": "Choose the scaling filter that will be applied when using resolution scale.\n\nBilinear works well for 3D games and is a safe default option.\n\nNearest is recommended for pixel art games.\n\nFSR 1.0 is merely a sharpening filter, not recommended for use with FXAA or SMAA.\n\nArea scaling is recommended when downscaling large resolutions to achieve a supersampled anti-aliasing effect.\n\nThis option can be changed while a game is running by clicking \"Apply\" below; you can simply move the settings window aside and experiment until you find your preferred look for a game.\n\nLeave on BILINEAR if unsure.",
   "GraphicsScalingFilterBilinear": "Bilinear",
   "GraphicsScalingFilterNearest": "Nearest",
   "GraphicsScalingFilterFsr": "FSR",
+  "GraphicsScalingFilterArea": "Area",
   "GraphicsScalingFilterLevelLabel": "Level",
   "GraphicsScalingFilterLevelTooltip": "Set FSR 1.0 sharpening level. Higher is sharper.",
   "SmaaLow": "SMAA Low",

src/Ryujinx/UI/Views/Settings/SettingsGraphicsView.axaml

@@ -1,4 +1,4 @@
-<UserControl
+<UserControl
     x:Class="Ryujinx.Ava.UI.Views.Settings.SettingsGraphicsView"
     xmlns="https://github.com/avaloniaui"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
@@ -173,6 +173,9 @@
                                 <ComboBoxItem>
                                     <TextBlock Text="{locale:Locale GraphicsScalingFilterFsr}" />
                                 </ComboBoxItem>
+                                <ComboBoxItem>
+                                    <TextBlock Text="{locale:Locale GraphicsScalingFilterArea}" />
+                                </ComboBoxItem>
                             </ComboBox>
                             <controls:SliderScroll Value="{Binding ScalingFilterLevel}"
                                     ToolTip.Tip="{locale:Locale GraphicsScalingFilterLevelTooltip}"