Add ability to change background dim colour in grayscale

osu.Game/Configuration/OsuConfigManager.cs

@@ -133,6 +133,7 @@ protected override void InitialiseDefaults()
             // Gameplay
             SetDefault(OsuSetting.PositionalHitsoundsLevel, 0.2f, 0, 1);
             SetDefault(OsuSetting.DimLevel, 0.7, 0, 1, 0.01);
+            SetDefault(OsuSetting.DimColour, 0, 0, 1, 0.01);
             SetDefault(OsuSetting.BlurLevel, 0, 0, 1, 0.01);
             SetDefault(OsuSetting.LightenDuringBreaks, true);
 
@@ -329,6 +330,7 @@ public enum OsuSetting
         AutoCursorSize,
         GameplayCursorDuringTouch,
         DimLevel,
+        DimColour,
         BlurLevel,
         EditorDim,
         LightenDuringBreaks,

osu.Game/Graphics/Backgrounds/Background.cs

@@ -31,13 +31,7 @@ public Background(string textureName = @"")
             this.textureName = textureName;
             RelativeSizeAxes = Axes.Both;
 
-            AddInternal(Sprite = new Sprite
-            {
-                RelativeSizeAxes = Axes.Both,
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                FillMode = FillMode.Fill,
-            });
+            AddInternal(Sprite = CreateSprite());
         }
 
         [BackgroundDependencyLoader]
@@ -47,24 +41,34 @@ private void load(LargeTextureStore textures)
                 Sprite.Texture = textures.Get(textureName);
         }
 
+        protected virtual Sprite CreateSprite() => new Sprite
+        {
+            RelativeSizeAxes = Axes.Both,
+            Anchor = Anchor.Centre,
+            Origin = Anchor.Centre,
+            FillMode = FillMode.Fill,
+        };
+
+        protected virtual BufferedContainer CreateBufferedContainer() => new BufferedContainer(cachedFrameBuffer: true)
+        {
+            RelativeSizeAxes = Axes.Both,
+            RedrawOnScale = false,
+            Child = Sprite
+        };
+
         public Vector2 BlurSigma => Vector2.Divide(bufferedContainer?.BlurSigma ?? Vector2.Zero, blurScale);
 
         /// <summary>
         /// Smoothly adjusts <see cref="IBufferedContainer.BlurSigma"/> over time.
         /// </summary>
         /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
-        public void BlurTo(Vector2 newBlurSigma, double duration = 0, Easing easing = Easing.None)
+        public virtual void BlurTo(Vector2 newBlurSigma, double duration = 0, Easing easing = Easing.None)
         {
             if (bufferedContainer == null && newBlurSigma != Vector2.Zero)
             {
                 RemoveInternal(Sprite, false);
 
-                AddInternal(bufferedContainer = new BufferedContainer(cachedFrameBuffer: true)
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    RedrawOnScale = false,
-                    Child = Sprite
-                });
+                AddInternal(bufferedContainer = CreateBufferedContainer());
             }
 
             if (bufferedContainer != null)

osu.Game/Graphics/Backgrounds/BeatmapBackground.cs

@@ -3,22 +3,60 @@
 
 #nullable disable
 
+using System.Runtime.InteropServices;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Rendering;
+using osu.Framework.Graphics.Shaders;
+using osu.Framework.Graphics.Shaders.Types;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Beatmaps;
 
 namespace osu.Game.Graphics.Backgrounds
 {
+    /// <summary>
+    /// A background which offers dimming using a custom shader with ability to change dim colour.
+    /// </summary>
     public partial class BeatmapBackground : Background
     {
         public readonly WorkingBeatmap Beatmap;
 
         private readonly string fallbackTextureName;
 
+        protected BeatmapBackgroundSprite ColouredDimmableSprite { get; private set; }
+
+        protected DimmableBufferedContainer ColouredDimmableBufferedContainer;
+
+        private Colour4 dimColour;
+
+        private float dimLevel;
+
+        public Colour4 DimColour
+        {
+            get => dimColour;
+            set => ColouredDimmable.DimColour = dimColour = value;
+        }
+
+        public float DimLevel
+        {
+            get => dimLevel;
+            set => ColouredDimmable.DimLevel = dimLevel = value;
+        }
+
+        /// <summary>
+        /// A drawable that currently handles dimming.
+        /// </summary>
+        protected IColouredDimmable ColouredDimmable => ColouredDimmableBufferedContainer != null ? ColouredDimmableBufferedContainer : ColouredDimmableSprite;
+
         public BeatmapBackground(WorkingBeatmap beatmap, string fallbackTextureName = @"Backgrounds/bg1")
         {
             Beatmap = beatmap;
             this.fallbackTextureName = fallbackTextureName;
+
+            DimColour = Colour4.Black;
+            DimLevel = 0.0f;
         }
 
         [BackgroundDependencyLoader]
@@ -27,6 +65,29 @@ private void load(LargeTextureStore textures)
             Sprite.Texture = Beatmap?.GetBackground() ?? textures.Get(fallbackTextureName);
         }
 
+        protected override Sprite CreateSprite() => ColouredDimmableSprite = new BeatmapBackgroundSprite
+        {
+            RelativeSizeAxes = Axes.Both,
+            Anchor = Anchor.Centre,
+            Origin = Anchor.Centre,
+            FillMode = FillMode.Fill,
+        };
+
+        protected override BufferedContainer CreateBufferedContainer()
+        {
+            ColouredDimmableSprite.DimColour = Colour4.Black;
+            ColouredDimmableSprite.DimLevel = 0.0f;
+
+            return ColouredDimmableBufferedContainer = new DimmableBufferedContainer(cachedFrameBuffer: true)
+            {
+                RelativeSizeAxes = Axes.Both,
+                RedrawOnScale = false,
+                Child = Sprite,
+                DimColour = DimColour,
+                DimLevel = DimLevel
+            };
+        }
+
         public override bool Equals(Background other)
         {
             if (ReferenceEquals(null, other)) return false;
@@ -35,5 +96,209 @@ public override bool Equals(Background other)
             return other.GetType() == GetType()
                    && ((BeatmapBackground)other).Beatmap == Beatmap;
         }
+
+        public interface IColouredDimmable : IDrawable
+        {
+            Colour4 DimColour { get; set; }
+
+            float DimLevel { get; set; }
+        }
+
+        public partial class DimmableBufferedContainer : BufferedContainer, IColouredDimmable
+        {
+            private Colour4 dimColour;
+
+            private float dimLevel;
+
+            public Colour4 DimColour
+            {
+                get => dimColour;
+                set
+                {
+                    dimColour = value;
+                    Invalidate(Invalidation.DrawNode);
+                }
+            }
+
+            public float DimLevel
+            {
+                get => dimLevel;
+                set
+                {
+                    dimLevel = value;
+                    Invalidate(Invalidation.DrawNode);
+                }
+            }
+
+            public DimmableBufferedContainer(RenderBufferFormat[] formats = null, bool pixelSnapping = false, bool cachedFrameBuffer = false)
+                : base(formats, pixelSnapping, cachedFrameBuffer)
+            {
+                DimColour = Colour4.Black;
+                DimLevel = 0.0f;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(ShaderManager shaders)
+            {
+                TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, "BeatmapBackground");
+            }
+
+            protected override DrawNode CreateDrawNode() => new DimmableBufferedContainerDrawNode(this, SharedData);
+
+            protected class DimmableBufferedContainerDrawNode : BufferedContainerDrawNode
+            {
+                public new DimmableBufferedContainer Source => (DimmableBufferedContainer)base.Source;
+
+                public DimmableBufferedContainerDrawNode(DimmableBufferedContainer source, BufferedContainerDrawNodeSharedData sharedData)
+                    : base(source, sharedData)
+                {
+                }
+
+                private Colour4 dimColour;
+
+                private float dimLevel;
+
+                public override void ApplyState()
+                {
+                    base.ApplyState();
+
+                    dimColour = Source.DimColour;
+                    dimLevel = Source.DimLevel;
+                }
+
+                private IUniformBuffer<BeatmapBackgroundParameters> beatmapBackgroundParametersBuffer;
+
+                protected override void BindUniformResources(IShader shader, IRenderer renderer)
+                {
+                    beatmapBackgroundParametersBuffer ??= renderer.CreateUniformBuffer<BeatmapBackgroundParameters>();
+
+                    beatmapBackgroundParametersBuffer.Data = beatmapBackgroundParametersBuffer.Data with
+                    {
+                        DimColour = new UniformVector4
+                        {
+                            X = dimColour.R,
+                            Y = dimColour.G,
+                            Z = dimColour.B,
+                            W = dimColour.A
+                        },
+                        DimLevel = dimLevel,
+                    };
+
+                    shader.BindUniformBlock("m_BeatmapBackgroundParameters", beatmapBackgroundParametersBuffer);
+                }
+
+                protected override void Dispose(bool isDisposing)
+                {
+                    base.Dispose(isDisposing);
+                    beatmapBackgroundParametersBuffer?.Dispose();
+                }
+
+                [StructLayout(LayoutKind.Sequential, Pack = 1)]
+                private record struct BeatmapBackgroundParameters
+                {
+                    public UniformVector4 DimColour;
+                    public UniformFloat DimLevel;
+                    private readonly UniformPadding12 pad1;
+                }
+            }
+        }
+
+        public partial class BeatmapBackgroundSprite : Sprite, IColouredDimmable
+        {
+            private Colour4 dimColour;
+
+            private float dimLevel;
+
+            public Colour4 DimColour
+            {
+                get => dimColour;
+                set
+                {
+                    dimColour = value;
+                    Invalidate(Invalidation.DrawNode);
+                }
+            }
+
+            public float DimLevel
+            {
+                get => dimLevel;
+                set
+                {
+                    dimLevel = value;
+                    Invalidate(Invalidation.DrawNode);
+                }
+            }
+
+            public BeatmapBackgroundSprite()
+            {
+                DimColour = Colour4.Black;
+                DimLevel = 0.0f;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(ShaderManager shaders)
+            {
+                TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, "BeatmapBackground");
+            }
+
+            protected override DrawNode CreateDrawNode() => new BeatmapBackgroundSpriteDrawNode(this);
+
+            public class BeatmapBackgroundSpriteDrawNode : SpriteDrawNode
+            {
+                public new BeatmapBackgroundSprite Source => (BeatmapBackgroundSprite)base.Source;
+
+                public BeatmapBackgroundSpriteDrawNode(BeatmapBackgroundSprite source)
+                    : base(source)
+                {
+                }
+
+                private Colour4 dimColour;
+
+                private float dimLevel;
+
+                public override void ApplyState()
+                {
+                    base.ApplyState();
+
+                    dimColour = Source.DimColour;
+                    dimLevel = Source.DimLevel;
+                }
+
+                private IUniformBuffer<BeatmapBackgroundParameters> beatmapBackgroundParametersBuffer;
+
+                protected override void BindUniformResources(IShader shader, IRenderer renderer)
+                {
+                    beatmapBackgroundParametersBuffer ??= renderer.CreateUniformBuffer<BeatmapBackgroundParameters>();
+
+                    beatmapBackgroundParametersBuffer.Data = beatmapBackgroundParametersBuffer.Data with
+                    {
+                        DimColour = new UniformVector4
+                        {
+                            X = dimColour.R,
+                            Y = dimColour.G,
+                            Z = dimColour.B,
+                            W = dimColour.A
+                        },
+                        DimLevel = dimLevel,
+                    };
+
+                    shader.BindUniformBlock("m_BeatmapBackgroundParameters", beatmapBackgroundParametersBuffer);
+                }
+
+                protected override void Dispose(bool isDisposing)
+                {
+                    base.Dispose(isDisposing);
+                    beatmapBackgroundParametersBuffer?.Dispose();
+                }
+
+                [StructLayout(LayoutKind.Sequential, Pack = 1)]
+                private record struct BeatmapBackgroundParameters
+                {
+                    public UniformVector4 DimColour;
+                    public UniformFloat DimLevel;
+                    private readonly UniformPadding12 pad1;
+                }
+            }
+        }
     }
 }

osu.Game/Graphics/Containers/UserDimContainer.cs

@@ -40,7 +40,7 @@ public abstract partial class UserDimContainer : Container
         /// <summary>
         /// Whether the content of this container is currently being displayed.
         /// </summary>
-        public bool ContentDisplayed { get; private set; }
+        public bool ContentDisplayed { get; protected set; }
 
         protected Bindable<double> UserDimLevel { get; private set; } = null!;
 

osu.Game/Localisation/GameplaySettingsStrings.cs

@@ -49,6 +49,11 @@ public static class GameplaySettingsStrings
         /// </summary>
         public static LocalisableString BackgroundBlur => new TranslatableString(getKey(@"blur"), @"Background blur");
 
+        /// <summary>
+        /// "Background dim colour"
+        /// </summary>
+        public static LocalisableString BackgroundDimColour => new TranslatableString(getKey(@"dim_colour"), @"Background dim colour");
+
         /// <summary>
         /// "Lighten playfield during breaks"
         /// </summary>