From 24321d68d450a5d33c071cc1572932b27068d706 Mon Sep 17 00:00:00 2001 From: ZenoArrows <129334871+ZenoArrows@users.noreply.github.com> Date: Tue, 10 Sep 2024 15:49:30 +0200 Subject: [PATCH] Add area sampling scaler to allow for super-sampled anti-aliasing. --- src/Ryujinx.Graphics.GAL/UpscaleType.cs | 1 + .../Effects/AreaScalingFilter.cs | 124 +++++++++++++ .../Effects/ShaderHelper.cs | 19 ++ .../Effects/Shaders/area_scaling.glsl | 171 +++++++++++++++++ .../Effects/Shaders/fsr_scaling.glsl | 2 +- .../Ryujinx.Graphics.OpenGL.csproj | 5 + src/Ryujinx.Graphics.OpenGL/Window.cs | 11 ++ .../Effects/AreaScalingFilter.cs | 120 ++++++++++++ .../Effects/Shaders/AreaScaling.glsl | 174 ++++++++++++++++++ .../Effects/Shaders/AreaScaling.spv | Bin 0 -> 13560 bytes .../Ryujinx.Graphics.Vulkan.csproj | 7 + src/Ryujinx.Graphics.Vulkan/Window.cs | 9 + src/Ryujinx/Assets/Locales/en_US.json | 3 +- .../Views/Settings/SettingsGraphicsView.axaml | 5 +- 14 files changed, 648 insertions(+), 3 deletions(-) create mode 100644 src/Ryujinx.Graphics.OpenGL/Effects/AreaScalingFilter.cs create mode 100644 src/Ryujinx.Graphics.OpenGL/Effects/Shaders/area_scaling.glsl create mode 100644 src/Ryujinx.Graphics.Vulkan/Effects/AreaScalingFilter.cs create mode 100644 src/Ryujinx.Graphics.Vulkan/Effects/Shaders/AreaScaling.glsl create mode 100644 src/Ryujinx.Graphics.Vulkan/Effects/Shaders/AreaScaling.spv diff --git a/src/Ryujinx.Graphics.GAL/UpscaleType.cs b/src/Ryujinx.Graphics.GAL/UpscaleType.cs index ca24199c43..e2482faef3 100644 --- a/src/Ryujinx.Graphics.GAL/UpscaleType.cs +++ b/src/Ryujinx.Graphics.GAL/UpscaleType.cs @@ -5,5 +5,6 @@ namespace Ryujinx.Graphics.GAL Bilinear, Nearest, Fsr, + Area, } } diff --git a/src/Ryujinx.Graphics.OpenGL/Effects/AreaScalingFilter.cs b/src/Ryujinx.Graphics.OpenGL/Effects/AreaScalingFilter.cs new file mode 100644 index 0000000000..cc4594298f --- /dev/null +++ b/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); + } + } +} diff --git a/src/Ryujinx.Graphics.OpenGL/Effects/ShaderHelper.cs b/src/Ryujinx.Graphics.OpenGL/Effects/ShaderHelper.cs index c25fe5b258..43b967331e 100644 --- a/src/Ryujinx.Graphics.OpenGL/Effects/ShaderHelper.cs +++ b/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); diff --git a/src/Ryujinx.Graphics.OpenGL/Effects/Shaders/area_scaling.glsl b/src/Ryujinx.Graphics.OpenGL/Effects/Shaders/area_scaling.glsl new file mode 100644 index 0000000000..16ad3c22ef --- /dev/null +++ b/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); +} diff --git a/src/Ryujinx.Graphics.OpenGL/Effects/Shaders/fsr_scaling.glsl b/src/Ryujinx.Graphics.OpenGL/Effects/Shaders/fsr_scaling.glsl index 8e8755db20..3c7d485b10 100644 --- a/src/Ryujinx.Graphics.OpenGL/Effects/Shaders/fsr_scaling.glsl +++ b/src/Ryujinx.Graphics.OpenGL/Effects/Shaders/fsr_scaling.glsl @@ -85,4 +85,4 @@ void main() { CurrFilter(gxy); gxy.x -= 8u; CurrFilter(gxy); -} \ No newline at end of file +} diff --git a/src/Ryujinx.Graphics.OpenGL/Ryujinx.Graphics.OpenGL.csproj b/src/Ryujinx.Graphics.OpenGL/Ryujinx.Graphics.OpenGL.csproj index 3d64da99bc..527c957b93 100644 --- a/src/Ryujinx.Graphics.OpenGL/Ryujinx.Graphics.OpenGL.csproj +++ b/src/Ryujinx.Graphics.OpenGL/Ryujinx.Graphics.OpenGL.csproj @@ -5,11 +5,16 @@ true + + + + + diff --git a/src/Ryujinx.Graphics.OpenGL/Window.cs b/src/Ryujinx.Graphics.OpenGL/Window.cs index 6bcfefa4ed..41115d99d6 100644 --- a/src/Ryujinx.Graphics.OpenGL/Window.cs +++ b/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; } diff --git a/src/Ryujinx.Graphics.Vulkan/Effects/AreaScalingFilter.cs b/src/Ryujinx.Graphics.Vulkan/Effects/AreaScalingFilter.cs new file mode 100644 index 0000000000..eb9ba27bcb --- /dev/null +++ b/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 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 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 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(); + } + } +} diff --git a/src/Ryujinx.Graphics.Vulkan/Effects/Shaders/AreaScaling.glsl b/src/Ryujinx.Graphics.Vulkan/Effects/Shaders/AreaScaling.glsl new file mode 100644 index 0000000000..af7a9285f3 --- /dev/null +++ b/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); +} diff --git a/src/Ryujinx.Graphics.Vulkan/Effects/Shaders/AreaScaling.spv b/src/Ryujinx.Graphics.Vulkan/Effects/Shaders/AreaScaling.spv new file mode 100644 index 0000000000000000000000000000000000000000..2f92113f74b106046cf97c95af775c99f4a76062 GIT binary patch literal 13560 zcmZQ(Qf6mhU}WHC;AIG9VgLg{1||kZ1_lOh1~xG5?i1{zS6q^!XJTpqQozT+45Gkt z{0wXitPBhcEDQ_`xrv#1APF5N1_l8JHn5l=1Bea5ATya6m>EFUtYZY};bL(2iFfz+ zclU9PPcA5kFD|LfNsZ6R%u9_=$t+4uF3BuQ1*zjeQkR*RoKu>Dtbmn)1#B10epUuH z22KVB2KUsGpw#00oYIoa{5%Z?237`k25yMBXI>eK6ay;*2LmreE<7_YCBGb18Z6Hb zk@w6i!&Cw?Ta8CV%u8PpjV7*aBGQ}c>5^Ye-sz$pPF2J&-pQE~(* zv4BzsNDLJBATdJ*ggQ_4wQy^VdAMN>8apwXJwcT6H89bD@iQ^ z$NOqV1_qEOP8nEI&CBRC0Q{K>cmbgc|M^XnZRaJ}ZM069YqLZn}SINkJ(n4}kpU&cwiw zUs~b}jec+%@0ulq24=^!MnF106<#Cu8s7wKg z@gV61=>dreAc=v>6p$FGtcK|Yl_?-GP?-%A1C=QtF&QMiAp1aKpt2OE4pgRq#6V@H zI|DPgyac(=oq>e`RK6%d{R88J%5a!GsLTP$BlAJ>AU}iDgW?KQmx0^>;)B8(q#oo~ z7$2k_WCe&H!UU?%85krP7#M^Zn80GAeg(N-oPmV_FC5VwQs7i$I<1`r<IcQU4g)(l{;z}TC^QT*3uMPVh*|J(yU)PD01^XXkUzK>Az=avKTsM| zXJP=yCn#<~@)}GKd5}0rUWj$|F=8vC@3}8E8=KX@2 z2Py+#YJM{^Fo48iYW_ggfXWS+n!k(;3?Ok>c>H5zU;ya@iG#v}5t?>E;Q^8ZB{UW$ zNO*wQFteGMAn}20KQj{p14ta?A5i)N@j?CpnF$IHkU22@tWf>PZewF&U;v53^n>`w z`a$Nv{K3w|zyPu%09u}MFflNI!U!Y|(ho}iATgMITu}Rv!=IapfdM2AQ^NyQgB-`a zObiSl@myATvSX1u_SwUlghz*==G>3=AM~n0^o+SwF}eSa^vuF))DafSD%&H4i!bC7Bo) zK;kepQcyL>aV*WmzyK15g@+6i0|Q7ONE{R%@<`zUl9OX%U{HdF2Z#+bTLEe|vi*uo z3=AM~kbgks4Tul&56DbVc!11-=~ss8M|PVE69WTC9Ht+{N7fHA2NoWxObiSlJ7DQY zjfsH)6h3v9^#Z7F1DOFTr}dc_7(n7R&^Chs69WTC45r5r zss~hN!}J(2F))C{VS0?27#KieAa{W3C=(_I29P-*agaMe&l z$RB}B3=AM~kollCO%M|U1ISL0zd&|@gh2s7%?y~ zfb@aHc^KHhacc~1i-Fn>AbFU1rcgUU?O2$3W(*7rAaR%)3#b}U+ZLwAl7WE%Bo4FF zih+Rvqz@zxvlBG91*&F2c7o(VX&n>>HVh05Aoqae|1mHzfcVH^1nRdShY_e>W(iFL zjtmUovAYgv`R@d3Z-K**fdOO|h>vU*Xv_}TEIzPWNZY~<>M!K7*`0xb0VEFdyC+l) za{24Uz`y_!hxy$bH15a1zyK15`P~O8yg~9X^ZcOZA(wyt3=9k)ahRGws2b!lE(kOx z$iTn=von~1fdQlsBo4DP1j$a2JS@CJ85kHq?g7bz!U)7i4kOUGC2|;n`n<64j$mK_ zk9)$xI}#e+AaRgcAU@12P(A>Sae~YO_3_LZn8AHPP=6Ve*2NeY7(nR<)b~hWU|<0C zJ3xF;nn(oqHy9WqpnZd61_lO@8jv`sr~#EbAp1b#$o7Hy-RSm##z#T+f%>wbcB~+1 zj0@WTfbl`&aUgqP_JhXJK>A?*&H#^ZGcdG5(^)110|Q76NIVdl&$2*csvyh3aRbSF z*-$Z1x`%~-4g&)NNG(VXRK9@52SH*myFr8EATf{}$Xy^lsO$lSXFdZ111L;E;voNn z_{jbTjsJq2fE?bSabJ-CL4ALie?enuApgSnpz#)DK4|P0nGYIYgz-WBh(@IF1M&Nj z_@M9wjX%QFgZQBFM`S)|3=)|S8iz#YgT^6Ye31E|aY$r7XdDum4;qI==7Yu|k@=u; zNMt@}91@ui8iz#YgT^6Yd{93HG!6;lgZu*;gGA>3#v+mVps`38A7nmgEE2{C=?9HR!uTNlpfO2gK4?r5 z#s}#KjY-1zApM|mNf;lbA2c=zZc#Z>BZdO6dP2{q=nt_1xrvWDY1iKy8Ii1_lO@ z9We8{pynahBi#%P3?OlsnjWYcAW99@7~Z7(jNw%HbId3=E(!0*Qm_QBeAv$-uw>N=G0$P(2C~n+2^$L2WdUJjgCk zc?c2*nGI4i2Q;?^4sX!R9s|Q%1_lO@7-)PCq#jfrg2Z6z=R?)Q_zR%(ZLs=fAp-*g zNDW9Fre+ZX0|O|pz|<^eU|;~L1Brv|0F|*IF_`+L3=9k)dtv-#Xm%`TU|;~L0g1!Z ztU$A4B?AKkNF7KVWCy6+28qGcuV!EX&n>~iY7J6Yf#g7XKxI2f9HwU-0|Nud9GIT< zNP0kWAU&Y+A0!TndrV#xb3koqkQ^vZLE_t>W2_)~ zklCQR1SAGCdneRvSpN*9XBPtl14tZZ_HHDzL2@v&_dv}C$%D)W)k`2TnA!WFenoco zeg*~xkT}fj14w3rNAiy%$!3|bCBJ5n1O)-Bn~s@2$DGh zjxjJWfZPbeZMAU3ED2aPeq%(}tAzyR_eER1h5Fff49Dso)iVqjnZiNn;~hN?l1hdT@m z3?Ok>xpJ3*fdQlsB;E*ZFFs&kU;v4O#;rka0kt1MVz74IBL)WWJU>Xh588))%)r0^ z5(l{xfq?-e22u+$7vx8f7)U)RKA$l#Fo5C!=Kkjl3=E*W zh3v-{3=9k)ahRHySp4{kfq?-e4)fz{1_lO@K9D%bEub>+4FdxMNF3%zP@4!O2J_=P zs2@S%Fh9O$U|;}=gWL&nGssUL(ERw3fq?-e22u<2BS;LS9^}VQ3=H6TWSILuL*0+; z$1e;F3?Olsny=7sK#s?63=9k)ahM;!GcYiK^nt`-e*D3}zyK15`4QC41Bt=>_zUVs zkT}ebzrk$<1_qEjL2d^5@ei6G|1vNzfW$y*VSWUOfz*Ti_>X~s0hE?u?*9*UKe8V| z3v58*Fg1*fkhn(nBNHP714ta^M`lpRgpq*(Bo6Z<3nK#qNF3%zP}>zG2J<5uBP6YY z#9@A9XJlXiiG$n;ax=(}9E_-Gm6MTy0VD=e3-cpL4CY=QsC$w9#LLLQ01}6(;bX+i zqx_5v3?Ok>nJmD_zyQ(*5{HQiGBPlL#6j~#pfMZJJdqG10|Q7L(gzZUiAjROj}bC|1#^oOBLf3S9OM>I zUjW1hu|fR+(AW;BO(O%Hj{wo%7+4tO7#SGkLGj1HzyOk0fXahtP#l2#sL03wUe5sI zD={*F*FS88j^imaGBAMDfW$##{UE+9BLmoMQ2PtShWS?&>R;seQDbCa0EvUr4k(?f zGcquM#6a^{FgrD%ZUBwjfz)U+GBAL|V0yF|85ltNK;j@jgZerkF_3!?< z4@%P@F_3;xS_bI{rDc#DsNV`p?=H~v45C5l-Hnlf!5t~RdqCwuG|X;KMh5UY92nn= zkpaBE2bSKw85tNrYCz(k^bX>?GBPlL%m%pw#D=9SUo7d$kCA}^Bn}F5P+a;mGBAL| zkkfkr)D5uo9>~bR01|`g31Vbm0Orz`14s=>9Aqyjy+<%IFo48i=>s$d01|_xk0@yR0ExrWM>Hb? z14ta?CXijA^bv!WK4KXe7(ikmwIKh1(mO~Dq#op-I7Ubt5$2zGX!=I>PXZ$Y14taE zClSp*NsJ5(AT=Oyn17N%Yn2!o7-0SZjbVVqVE##k`UfNq^G_Nh0|Q7LAmBP`@8C{#XiH=LO2Y z(6LsK8_J+=fThoJMg|6u7${sp@m0adzyQ(*5(oJiH1-1$1Ni|YU&+Y801|`otI*=A z8npI}k%0ju4l)yz_G%az7(n8%xB`tIfy7{ORR@hLkT}R(P`uQm#Y+Pt0|Q75q!#2Z zP&xyNfyxn3xP!t6M1%B${MiWgC#)Q50)-1BXk85h14ut8ESwk%0lE4kQlpCunRABnDCs z3YR`;nuEoEKO+MJNDL$oa>oR;`gS6;zJi%QiIIT;qy{7o>-SA&WMBZ91Cj%o1F~ld zwCsi1GnJ8n0VD>J2iY?XTF$}v)1l=A%$^yH3=AMOAaR&IGZ`5eK<0qtVCrTuGBAMb z2g!l_3mSU_iGj=oxnmBRf9EnXFo48h^7GK#IiHb%0VD>qa{(g*14s`@9ArLdEE6OK z(ho|f3!&*0#0U9n5hDY5ttO1Wn2~`23IhWJNH0h&NFLO72C3b|$iM(H8>9vl7a(_m z#9(FOW<~}Euo%>BAir;6WMBY^!_;hrszGiqZewI%0Exrmd^;lp14ti892A})J}f*z z?f|WM2Mv3I)+EBhO$9pUsm8#-01G$JI$Mx>5Fa#-brfm66^MTw%7?jaH>fShz`%f9 zH|}9%U;v53)a-?-L3aN>P~HKxGoa%Q`xzM+K>9%9pl|}Y10)7A12k`Z0JFk?;?_UApIad zNDasjpm4qf^(XR}_hm)~29P*R%@wE`v&_!ucjrID_PF zFfuSahK4hU4Kw=|7PD_NGBAL|VQTI`)gZg^E+Yd2NE}uk-D6~60O$m_1Lh z*z=T;fdM2A(+}b!>j#+wi?e5p3=AMUVCFqXG7qF5#0RMXsR!lN7f^Xnz6Y^E`5pjq CvqqQz literal 0 HcmV?d00001 diff --git a/src/Ryujinx.Graphics.Vulkan/Ryujinx.Graphics.Vulkan.csproj b/src/Ryujinx.Graphics.Vulkan/Ryujinx.Graphics.Vulkan.csproj index f6a7be91e4..6ee9a883f7 100644 --- a/src/Ryujinx.Graphics.Vulkan/Ryujinx.Graphics.Vulkan.csproj +++ b/src/Ryujinx.Graphics.Vulkan/Ryujinx.Graphics.Vulkan.csproj @@ -13,6 +13,13 @@ + + + + + + + diff --git a/src/Ryujinx.Graphics.Vulkan/Window.cs b/src/Ryujinx.Graphics.Vulkan/Window.cs index d67362be30..c4aaa2ece9 100644 --- a/src/Ryujinx.Graphics.Vulkan/Window.cs +++ b/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; } diff --git a/src/Ryujinx/Assets/Locales/en_US.json b/src/Ryujinx/Assets/Locales/en_US.json index 74e18056ba..a592139b22 100644 --- a/src/Ryujinx/Assets/Locales/en_US.json +++ b/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", diff --git a/src/Ryujinx/UI/Views/Settings/SettingsGraphicsView.axaml b/src/Ryujinx/UI/Views/Settings/SettingsGraphicsView.axaml index 5cffc6848a..0a12575adc 100644 --- a/src/Ryujinx/UI/Views/Settings/SettingsGraphicsView.axaml +++ b/src/Ryujinx/UI/Views/Settings/SettingsGraphicsView.axaml @@ -1,4 +1,4 @@ - + + +