bloom fix

fluXis.Resources/Shaders/sh_BlurCompose.fs

@@ -0,0 +1,20 @@
+layout(set = 0, binding = 0) uniform texture2D u_Original;
+layout(set = 0, binding = 1) uniform sampler s_Original;
+
+layout(set = 1, binding = 0) uniform texture2D u_Blurred;
+layout(set = 1, binding = 1) uniform sampler s_Blurred;
+
+layout(set = 2, binding = 0) uniform m_BlurComposeParameters
+{
+    float g_Strength;
+};
+
+layout(location = 2) in vec2 v_TexCoord;
+layout(location = 0) out vec4 o_Colour;
+
+void main()
+{
+    vec3 scene = texture(sampler2D(u_Original, s_Original), v_TexCoord).rgb;
+    vec3 blur  = texture(sampler2D(u_Blurred,  s_Blurred),  v_TexCoord).rgb;
+    o_Colour = vec4(scene + blur * g_Strength, 1.0);
+}

fluXis/Graphics/Shaders/Bloom/BloomShaderStep.cs

@@ -1,8 +1,8 @@
-using System;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
 using fluXis.Map.Structures.Events;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Rendering;
+using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Shaders.Types;
 using osu.Framework.Utils;
 using osuTK;
@@ -12,53 +12,81 @@ namespace fluXis.Graphics.Shaders.Bloom;
 public class BloomShaderStep : ShaderStep<BloomShaderStep.BlurParameters>
 {
     protected override string FragmentShader => "Blur";
+    protected string ComposeFragmentShader => "BlurCompose";
+    private IShader blurComposeShader;
+    private IUniformBuffer<BlurComposeParameters> composeParameterBuffer;
     public override ShaderType Type => ShaderType.Bloom;
 
     public override int Passes => 1;
 
     private int kernelRadius;
     private float sigma;
-    private float radians;
+    private Vector2 direction;
+    public override void EnsureParameters(IRenderer renderer)
+    {
+        ParameterBuffer ??= renderer.CreateUniformBuffer<BlurParameters>();
+        composeParameterBuffer ??= renderer.CreateUniformBuffer<BlurComposeParameters>();
+    }
+    public override void UpdateParameters(IFrameBuffer current)
+    {
+        ParameterBuffer.Data = ParameterBuffer.Data with
+        {
+            Radius = kernelRadius,
+            Sigma = sigma,
+            TexSize = current.Size,
+            Direction = direction
+        };
+        composeParameterBuffer.Data = composeParameterBuffer.Data with
+        {
+            Strength = Strength
+        };
+    }
 
-    public override void UpdateParameters(IFrameBuffer current) => ParameterBuffer.Data = ParameterBuffer.Data with
+    public override void LoadShader(ShaderManager shaders)
     {
-        Radius = kernelRadius,
-        Sigma = sigma,
-        TexSize = current.Size,
-        Direction = new Vector2(MathF.Cos(radians), MathF.Sin(radians))
-    };
+        base.LoadShader(shaders);
+        blurComposeShader = shaders.Load(VertexShader, ComposeFragmentShader);
+    }
 
     private IFrameBuffer buffer;
+    private IFrameBuffer buffer2;
+
+    private void drawBlurPass(IRenderer renderer, IFrameBuffer src, IFrameBuffer dst, Vector2 blurDirection)
+    {
+        direction = blurDirection;
+        UpdateParameters(src);
+        Shader.BindUniformBlock($"m_{nameof(BlurParameters)}", ParameterBuffer);
+        dst.Bind();
+        Shader.Bind();
+
+        DrawFrameBuffer(renderer, src);
 
-    public override void DrawBuffer(IRenderer renderer, IFrameBuffer current)
+        Shader.Unbind();
+        dst.Unbind();
+    }
+    public override void DrawBuffer(IRenderer renderer, IFrameBuffer current, IFrameBuffer target)
     {
         sigma = 20 * Strength;
         kernelRadius = Blur.KernelSize(sigma);
         DrawColor = Colour4.White;
 
         buffer ??= renderer.CreateFrameBuffer();
         buffer.Size = current.Size;
+        buffer2 ??= renderer.CreateFrameBuffer();
+        buffer2.Size = current.Size;
 
-        TargetBuffer.Unbind();
-        buffer.Bind();
-
-        radians = 0;
-        UpdateParameters(buffer);
-        DrawFrameBuffer(renderer, current);
-
-        radians = 90;
-        UpdateParameters(buffer);
-        // base.DrawBuffer(renderer, buffer);
+        target.Unbind();
 
-        buffer.Unbind();
-        TargetBuffer.Bind();
+        drawBlurPass(renderer, current, buffer, Vector2.UnitX);
+        drawBlurPass(renderer, buffer, buffer2, Vector2.UnitY);
 
-        // DrawFrameBuffer(renderer, current);
-        DrawFrameBuffer(renderer, buffer);
+        blurComposeShader.BindUniformBlock($"m_{nameof(BlurComposeParameters)}", composeParameterBuffer);
+        target.Bind();
 
-        // renderer.SetBlend(BlendingParameters.Additive);
-        // DrawColor = Colour4.White.Opacity(Strength);
-        // DrawFrameBuffer(renderer, buffer);
+        blurComposeShader.Bind();
+        renderer.BindTexture(buffer2.Texture, 1);
+        DrawFrameBuffer(renderer, current);
+        blurComposeShader.Unbind();
     }
 
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
@@ -70,4 +98,10 @@ public record struct BlurParameters
         public UniformVector2 Direction;
         private readonly UniformPadding8 pad1;
     }
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public record struct BlurComposeParameters
+    {
+        public UniformFloat Strength;
+        private readonly UniformPadding12 pad1;
+    }
 }

fluXis/Graphics/Shaders/ShaderStackContainer.cs

@@ -186,7 +186,7 @@ protected override void PopulateContents(IRenderer renderer)
 
                     using (BindFrameBuffer(target))
                     {
-                        shader.DrawBuffer(renderer, current);
+                        shader.DrawBuffer(renderer, current, target);
                     }
                 }
             }

fluXis/Graphics/Shaders/ShaderStep.cs

@@ -37,27 +37,27 @@ protected ShaderStep()
         TransformHandler = new ShaderTransformHandler(this);
     }
 
-    public void LoadShader(ShaderManager shaders)
+    public virtual void LoadShader(ShaderManager shaders)
     {
         Shader = shaders.Load(VertexShader, FragmentShader);
     }
 
     public virtual void EnsureParameters(IRenderer renderer) { }
     public abstract void UpdateParameters(IFrameBuffer current);
 
-    public virtual void DrawBuffer(IRenderer renderer, IFrameBuffer current)
+    public virtual void DrawBuffer(IRenderer renderer, IFrameBuffer current, IFrameBuffer target)
     {
     }
 }
 
 public abstract class ShaderStep<T> : ShaderStep
     where T : unmanaged, IEquatable<T>
 {
-    protected IUniformBuffer<T> ParameterBuffer { get; private set; }
+    protected IUniformBuffer<T> ParameterBuffer { get; set; }
 
     public override void EnsureParameters(IRenderer renderer) => ParameterBuffer ??= renderer.CreateUniformBuffer<T>();
 
-    public override void DrawBuffer(IRenderer renderer, IFrameBuffer current)
+    public override void DrawBuffer(IRenderer renderer, IFrameBuffer current, IFrameBuffer target)
     {
         var name = typeof(T).Name;
         Shader.BindUniformBlock($"m_{name}", ParameterBuffer);