[FEATURE] Add Multiple Blur Shaders

fluXis.Resources/Shaders/sh_AdditiveComposeDithered.fs

@@ -0,0 +1,26 @@
+layout(set = 0, binding = 0) uniform texture2D u_Base;
+layout(set = 0, binding = 1) uniform sampler s_base;
+
+layout(set = 1, binding = 0) uniform texture2D u_Additive;
+layout(set = 1, binding = 1) uniform sampler s_Additive;
+
+layout(set = 2, binding = 0) uniform m_AdditiveComposeParameters
+{
+    float g_Strength;
+};
+
+layout(location = 2) in vec2 v_TexCoord;
+layout(location = 0) out vec4 o_Colour;
+
+mediump float dither(vec2 uv) {
+    return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453) - 0.5;
+}
+
+void main()
+{
+    vec3 scene = texture(sampler2D(u_Base, s_base), v_TexCoord).rgb;
+    vec3 add = texture(sampler2D(u_Additive,  s_Additive),  v_TexCoord).rgb;
+    mediump vec3 noise = vec3(dither(gl_FragCoord.xy) * g_Strength * 5) / 255.0;
+
+    o_Colour = vec4(scene + noise + add * g_Strength, 1.0);
+}

fluXis.Resources/Shaders/sh_Dither.fs

@@ -0,0 +1,31 @@
+#ifndef DITHER_FS
+#define DITHER_FS
+
+#include "sh_Utils.h"
+
+layout(location = 2) in mediump vec2 v_TexCoord;
+layout(set = 1, binding = 0) uniform lowp texture2D m_Texture;
+layout(set = 1, binding = 1) uniform lowp sampler m_Sampler;
+
+layout(std140, set = 0, binding = 0) uniform m_DitherParameters
+{
+    mediump float g_Strength;
+};
+
+layout(location = 0) out vec4 o_Colour;
+
+mediump float dither(vec2 uv) {
+    return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453) - 0.5;
+}
+
+void main(void)
+{
+    vec4 texColor = texture(sampler2D(m_Texture, m_Sampler), v_TexCoord);
+
+    mediump vec3 noise = vec3(dither(gl_FragCoord.xy) * g_Strength) / 255.0;
+
+    texColor.rgb += noise;
+
+    o_Colour = texColor;
+}
+#endif

fluXis.Resources/Shaders/sh_RadialBlur.fs

@@ -0,0 +1,66 @@
+#define SAMPLES 20
+
+layout(std140, set = 0, binding = 0) uniform m_BlurParameters
+{
+    vec2 g_TexSize;
+    vec2 g_Pos;
+    float g_Sigma;
+};
+
+layout(set = 1, binding = 0) uniform texture2D m_Texture;
+layout(set = 1, binding = 1) uniform sampler m_Sampler;
+
+layout(location = 2) in vec2 v_TexCoord;
+layout(location = 0) out vec4 o_Colour;
+
+mediump float dither(vec2 uv)
+{
+    return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453) - 0.5;
+}
+
+void main()
+{
+    vec2 uv = v_TexCoord;
+    vec2 delta = uv - g_Pos;
+
+    float aspect = g_TexSize.x / g_TexSize.y;
+    float invAspect = 1.0 / aspect;
+    delta.x *= aspect;
+
+    float angleStep = ((g_Sigma - 0.5) * 4.0) / float(SAMPLES);
+
+    float jitter = dither(uv) * angleStep;
+    float sinJitter = sin(jitter);
+    float cosJitter = cos(jitter);
+
+    vec2 rotated = vec2(
+        cosJitter * delta.x - sinJitter * delta.y,
+        sinJitter * delta.x + cosJitter * delta.y
+    );
+
+    float sinStep = sin(angleStep);
+    float cosStep = cos(angleStep);
+
+    vec4 color = vec4(0.0);
+    float validSamples = 0.0;
+
+    for (int i = 0; i < SAMPLES; ++i)
+    {
+        vec2 sampleUV = g_Pos + vec2(rotated.x * invAspect, rotated.y);
+
+        vec2 inside = step(vec2(0.0), sampleUV) * step(sampleUV, vec2(1.0));
+        float factor = inside.x * inside.y;
+
+        color += texture(sampler2D(m_Texture, m_Sampler), sampleUV) * factor;
+        validSamples += factor;
+
+        rotated = vec2(
+            cosStep * rotated.x - sinStep * rotated.y,
+            sinStep * rotated.x + cosStep * rotated.y
+        );
+    }
+
+    o_Colour = (validSamples > 0.0)
+        ? color / validSamples
+        : texture(sampler2D(m_Texture, m_Sampler), uv);
+}

fluXis.Resources/Shaders/sh_ZoomBlur.fs

@@ -0,0 +1,49 @@
+#define SAMPLES 20
+
+layout(std140, set = 0, binding = 0) uniform m_BlurParameters
+{
+    vec2 g_TexSize;
+    vec2 g_Pos;
+    float g_Sigma;
+};
+
+layout(set = 1, binding = 0) uniform texture2D m_Texture;
+layout(set = 1, binding = 1) uniform sampler m_Sampler;
+
+layout(location = 2) in vec2 v_TexCoord;
+layout(location = 0) out vec4 o_Colour;
+
+mediump float dither(vec2 uv)
+{
+    return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453) - 0.5;
+}
+
+void main()
+{
+    vec2  uv    = v_TexCoord;
+    vec2  delta = uv - g_Pos;
+
+    float sigma = (g_Sigma - 0.5) * 4.0;
+    float scaleStep = sigma / float(SAMPLES);
+    float jitter = dither(uv);
+
+    vec4  color = vec4(0.0);
+    float validSamples = 0.0;
+
+    for (int i = 0; i < SAMPLES; ++i)
+    {
+        float scale = 1.0 - (float(i) + jitter) * scaleStep;
+        vec2 sampleUV = g_Pos + delta * scale;
+
+        vec2 inside = step(vec2(0.0), sampleUV) * step(sampleUV, vec2(1.0));
+        float factor = inside.x * inside.y;
+
+        color += texture(sampler2D(m_Texture, m_Sampler), sampleUV) * factor;
+        validSamples += factor;
+    }
+
+    if (validSamples > 0.0)
+        o_Colour = color / validSamples;
+    else
+        o_Colour = texture(sampler2D(m_Texture, m_Sampler), uv);
+}

fluXis.sln.DotSettings

@@ -550,4 +550,5 @@ private void load()
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Bindables/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=filenames/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=localisable/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=shaders/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=shaders/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Veldrid/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

fluXis/Graphics/Shaders/ShaderStackContainer.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using fluXis.Graphics.Shaders.Steps;
 using fluXis.Map.Structures.Events;
+using fluXis.Utils.Extensions;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -127,6 +128,10 @@ public ShaderStep GetShader(ShaderType type)
         ShaderType.FishEye => new FishEyeShaderStep(),
         ShaderType.Reflections => new ReflectionsShaderStep(),
         ShaderType.Glitch2 => new Glitch2ShaderStep(),
+        ShaderType.GaussianBlur => new GaussianBlurStep(),
+        ShaderType.RadialBlur => new RadialBlurStep(),
+        ShaderType.ZoomBlur => new ZoomBlurStep(),
+        ShaderType.MotionBlur => new MotionBlurStep(),
         _ => null
     };
 
@@ -165,6 +170,8 @@ protected override void PopulateContents(IRenderer renderer)
             foreach (var shader in Source.shaders)
             {
                 shader.Time = Source.Time;
+                // OpenGL needs different implementations in some shaders
+                shader.UsingVeldrid = renderer.IsVeldrid();
                 shader.EnsureParameters(renderer);
 
                 if (!shader.ShouldRender)

fluXis/Graphics/Shaders/ShaderStep.cs

@@ -6,6 +6,7 @@
 using osu.Framework.Graphics.Rendering;
 using osu.Framework.Graphics.Shaders;
 using osu.Framework.Timing;
+using osuTK;
 
 namespace fluXis.Graphics.Shaders;
 
@@ -19,6 +20,8 @@ public abstract class ShaderStep : IHasStrength
     public abstract ShaderType Type { get; }
     public ShaderTransformHandler TransformHandler { get; }
 
+    public bool UsingVeldrid = true;
+
     public float Strength { get; set; }
     public float Strength2 { get; set; }
     public float Strength3 { get; set; }
@@ -42,12 +45,40 @@ public virtual void LoadShader(ShaderManager shaders)
         Shader = shaders.Load(VertexShader, FragmentShader);
     }
 
+    protected virtual void EnsureBuffer(IRenderer renderer, ref IFrameBuffer buffer, Vector2 size)
+    {
+        buffer ??= renderer.CreateFrameBuffer();
+        buffer.Size = size;
+    }
+
     public virtual void EnsureParameters(IRenderer renderer) { }
     public abstract void UpdateParameters(IFrameBuffer current);
 
     public virtual void DrawBuffer(IRenderer renderer, IFrameBuffer current, IFrameBuffer target)
     {
     }
+
+    protected virtual void DrawScaledBuffer(IRenderer renderer, IFrameBuffer src, IFrameBuffer dst, IShader shader, bool forceProjection = true)
+    {
+        if (forceProjection)
+        {
+            renderer.PushOrtho(new RectangleF(0, 0, dst.Size.X, dst.Size.Y));
+        }
+
+        dst.Bind();
+        shader?.Bind();
+
+        var drawRect = new RectangleF(0, 0, dst.Size.X, dst.Size.Y);
+        renderer.DrawFrameBuffer(src, drawRect, Colour4.White);
+
+        shader?.Unbind();
+        dst.Unbind();
+
+        if (forceProjection)
+        {
+            renderer.PopOrtho();
+        }
+    }
 }
 
 public abstract class ShaderStep<T> : ShaderStep