Merge pull request #8523 from smoogipoo/mania-note-skinning

Add mania note skinning

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneColumnHitObjectArea.cs

@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneColumnHitObjectArea : ManiaSkinnableTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            SetContents(() => new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.8f),
+                Direction = FillDirection.Horizontal,
+                Children = new Drawable[]
+                {
+                    new ColumnTestContainer(0, ManiaAction.Key1)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                        Child = new ColumnHitObjectArea(new HitObjectContainer())
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        }
+                    },
+                    new ColumnTestContainer(1, ManiaAction.Key2)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                        Child = new ColumnHitObjectArea(new HitObjectContainer())
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        }
+                    }
+                }
+            });
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneHoldNote.cs

@@ -0,0 +1,24 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneHoldNote : ManiaHitObjectTestScene
+    {
+        protected override DrawableManiaHitObject CreateHitObject()
+        {
+            var note = new HoldNote { Duration = 1000 };
+            note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            return new DrawableHoldNote(note)
+            {
+                Height = 200,
+            };
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneNote.cs

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneNote : ManiaHitObjectTestScene
+    {
+        protected override DrawableManiaHitObject CreateHitObject()
+        {
+            var note = new Note();
+            note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            return new DrawableNote(note);
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/TestSceneHitExplosion.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Origin = Anchor.Centre,
                 RelativePositionAxes = Axes.Y,
                 Y = -0.25f,
-                Size = new Vector2(Column.COLUMN_WIDTH, NotePiece.NOTE_HEIGHT),
+                Size = new Vector2(Column.COLUMN_WIDTH, DefaultNotePiece.NOTE_HEIGHT),
             };
 
             int runcount = 0;

osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditNotePiece.cs

@@ -12,12 +12,12 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
     {
         public EditNotePiece()
         {
-            Height = NotePiece.NOTE_HEIGHT;
+            Height = DefaultNotePiece.NOTE_HEIGHT;
 
             CornerRadius = 5;
             Masking = true;
 
-            InternalChild = new NotePiece();
+            InternalChild = new DefaultNotePiece();
         }
 
         [BackgroundDependencyLoader]

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs

@@ -122,11 +122,11 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             switch (scrollingInfo.Direction.Value)
             {
                 case ScrollingDirection.Up:
-                    mousePosition.Y -= NotePiece.NOTE_HEIGHT / 2;
+                    mousePosition.Y -= DefaultNotePiece.NOTE_HEIGHT / 2;
                     break;
 
                 case ScrollingDirection.Down:
-                    mousePosition.Y += NotePiece.NOTE_HEIGHT / 2;
+                    mousePosition.Y += DefaultNotePiece.NOTE_HEIGHT / 2;
                     break;
             }
 
@@ -143,11 +143,11 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             switch (scrollingInfo.Direction.Value)
             {
                 case ScrollingDirection.Up:
-                    hitObjectPosition.Y += NotePiece.NOTE_HEIGHT / 2;
+                    hitObjectPosition.Y += DefaultNotePiece.NOTE_HEIGHT / 2;
                     break;
 
                 case ScrollingDirection.Down:
-                    hitObjectPosition.Y -= NotePiece.NOTE_HEIGHT / 2;
+                    hitObjectPosition.Y -= DefaultNotePiece.NOTE_HEIGHT / 2;
                     break;
             }
 

osu.Game.Rulesets.Mania/ManiaSkinComponent.cs

@@ -19,7 +19,11 @@ namespace osu.Game.Rulesets.Mania
 
     public enum ManiaSkinComponents
     {
+        ColumnBackground,
+        HitTarget,
         KeyArea,
-        ColumnBackground
+        Note,
+        HoldNoteHead,
+        HoldNoteTail,
     }
 }

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNoteHead.cs

@@ -8,6 +8,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// </summary>
     public class DrawableHoldNoteHead : DrawableNote
     {
+        protected override ManiaSkinComponents Component => ManiaSkinComponents.HoldNoteHead;
+
         public DrawableHoldNoteHead(DrawableHoldNote holdNote)
             : base(holdNote.HitObject.Head)
         {

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNoteTail.cs

@@ -18,6 +18,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         /// </summary>
         private const double release_window_lenience = 1.5;
 
+        protected override ManiaSkinComponents Component => ManiaSkinComponents.HoldNoteTail;
+
         private readonly DrawableHoldNote holdNote;
 
         public DrawableHoldNoteTail(DrawableHoldNote holdNote)

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableNote.cs

@@ -3,13 +3,12 @@
 
 using System.Diagnostics;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Effects;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
@@ -18,7 +17,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// </summary>
     public class DrawableNote : DrawableManiaHitObject<Note>, IKeyBindingHandler<ManiaAction>
     {
-        private readonly NotePiece headPiece;
+        protected virtual ManiaSkinComponents Component => ManiaSkinComponents.Note;
+
+        private readonly Drawable headPiece;
 
         public DrawableNote(Note hitObject)
             : base(hitObject)
@@ -26,22 +27,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
 
-            CornerRadius = 5;
+            AddInternal(headPiece = new SkinnableDrawable(new ManiaSkinComponent(Component), _ => new DefaultNotePiece())
-            Masking = true;
-
-            AddInternal(headPiece = new NotePiece());
-
-            AccentColour.BindValueChanged(colour =>
             {
-                headPiece.AccentColour = colour.NewValue;
+                RelativeSizeAxes = Axes.X,
-
+                AutoSizeAxes = Axes.Y
-                EdgeEffect = new EdgeEffectParameters
+            });
-                {
-                    Type = EdgeEffectType.Glow,
-                    Colour = colour.NewValue.Lighten(1f).Opacity(0.2f),
-                    Radius = 10,
-                };
-            }, true);
         }
 
         protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> e)

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/DefaultNotePiece.cs

@@ -0,0 +1,85 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osuTK.Graphics;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
+{
+    /// <summary>
+    /// Represents the static hit markers of notes.
+    /// </summary>
+    internal class DefaultNotePiece : CompositeDrawable
+    {
+        public const float NOTE_HEIGHT = 12;
+
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+        private readonly IBindable<Color4> accentColour = new Bindable<Color4>();
+
+        private readonly Box colouredBox;
+
+        public DefaultNotePiece()
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = NOTE_HEIGHT;
+
+            CornerRadius = 5;
+            Masking = true;
+
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both
+                },
+                colouredBox = new Box
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = NOTE_HEIGHT / 2,
+                    Alpha = 0.1f
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader(true)]
+        private void load([NotNull] IScrollingInfo scrollingInfo, [CanBeNull] DrawableHitObject drawableObject)
+        {
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(onDirectionChanged, true);
+
+            if (drawableObject != null)
+            {
+                accentColour.BindTo(drawableObject.AccentColour);
+                accentColour.BindValueChanged(onAccentChanged, true);
+            }
+        }
+
+        private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            colouredBox.Anchor = colouredBox.Origin = direction.NewValue == ScrollingDirection.Up
+                ? Anchor.TopCentre
+                : Anchor.BottomCentre;
+        }
+
+        private void onAccentChanged(ValueChangedEvent<Color4> accent)
+        {
+            colouredBox.Colour = accent.NewValue.Lighten(0.9f);
+
+            EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = accent.NewValue.Lighten(1f).Opacity(0.2f),
+                Radius = 10,
+            };
+        }
+    }
+}

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/NotePiece.cs

@@ -1,73 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osuTK.Graphics;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.UI.Scrolling;
-
-namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
-{
-    /// <summary>
-    /// Represents the static hit markers of notes.
-    /// </summary>
-    internal class NotePiece : Container, IHasAccentColour
-    {
-        public const float NOTE_HEIGHT = 12;
-
-        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
-
-        private readonly Box colouredBox;
-
-        public NotePiece()
-        {
-            RelativeSizeAxes = Axes.X;
-            Height = NOTE_HEIGHT;
-
-            Children = new[]
-            {
-                new Box
-                {
-                    RelativeSizeAxes = Axes.Both
-                },
-                colouredBox = new Box
-                {
-                    RelativeSizeAxes = Axes.X,
-                    Height = NOTE_HEIGHT / 2,
-                    Alpha = 0.1f
-                }
-            };
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(IScrollingInfo scrollingInfo)
-        {
-            direction.BindTo(scrollingInfo.Direction);
-            direction.BindValueChanged(dir =>
-            {
-                colouredBox.Anchor = colouredBox.Origin = dir.NewValue == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
-            }, true);
-        }
-
-        private Color4 accentColour;
-
-        public Color4 AccentColour
-        {
-            get => accentColour;
-            set
-            {
-                if (accentColour == value)
-                    return;
-
-                accentColour = value;
-
-                colouredBox.Colour = AccentColour.Lighten(0.9f);
-            }
-        }
-    }
-}

osu.Game.Rulesets.Mania/Skinning/LegacyHitTarget.cs

@@ -0,0 +1,84 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Skinning
+{
+    public class LegacyHitTarget : CompositeDrawable
+    {
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        [Resolved(CanBeNull = true)]
+        private ManiaStage stage { get; set; }
+
+        private Container directionContainer;
+
+        public LegacyHitTarget()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin, IScrollingInfo scrollingInfo)
+        {
+            string targetImage = skin.GetConfig<LegacyManiaSkinConfigurationLookup, string>(
+                                     new LegacyManiaSkinConfigurationLookup(stage?.Columns.Count ?? 4, LegacyManiaSkinConfigurationLookups.HitTargetImage))?.Value
+                                 ?? "mania-stage-hint";
+
+            bool showJudgementLine = skin.GetConfig<LegacyManiaSkinConfigurationLookup, bool>(
+                                         new LegacyManiaSkinConfigurationLookup(stage?.Columns.Count ?? 4, LegacyManiaSkinConfigurationLookups.ShowJudgementLine))?.Value
+                                     ?? true;
+
+            InternalChild = directionContainer = new Container
+            {
+                Origin = Anchor.CentreLeft,
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Children = new Drawable[]
+                {
+                    new Sprite
+                    {
+                        Texture = skin.GetTexture(targetImage),
+                        Scale = new Vector2(1, 0.9f * 1.6025f),
+                        RelativeSizeAxes = Axes.X,
+                        Width = 1
+                    },
+                    new Box
+                    {
+                        Anchor = Anchor.CentreLeft,
+                        RelativeSizeAxes = Axes.X,
+                        Height = 1,
+                        Alpha = showJudgementLine ? 0.9f : 0
+                    }
+                }
+            };
+
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(onDirectionChanged, true);
+        }
+
+        private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            if (direction.NewValue == ScrollingDirection.Up)
+            {
+                directionContainer.Anchor = Anchor.TopLeft;
+                directionContainer.Scale = new Vector2(1, -1);
+            }
+            else
+            {
+                directionContainer.Anchor = Anchor.BottomLeft;
+                directionContainer.Scale = Vector2.One;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Mania/Skinning/LegacyHoldNoteHeadPiece.cs

@@ -0,0 +1,17 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics.Textures;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Mania.Skinning
+{
+    public class LegacyHoldNoteHeadPiece : LegacyNotePiece
+    {
+        protected override Texture GetTexture(ISkinSource skin)
+        {
+            return GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage)
+                   ?? GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Skinning/LegacyHoldNoteTailPiece.cs

@@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Mania.Skinning
+{
+    public class LegacyHoldNoteTailPiece : LegacyNotePiece
+    {
+        protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            // Invert the direction
+            base.OnDirectionChanged(direction.NewValue == ScrollingDirection.Up
+                ? new ValueChangedEvent<ScrollingDirection>(ScrollingDirection.Down, ScrollingDirection.Down)
+                : new ValueChangedEvent<ScrollingDirection>(ScrollingDirection.Up, ScrollingDirection.Up));
+        }
+
+        protected override Texture GetTexture(ISkinSource skin)
+        {
+            return GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteTailImage)
+                   ?? GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Skinning/LegacyNotePiece.cs

@@ -0,0 +1,93 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Skinning
+{
+    public class LegacyNotePiece : LegacyManiaColumnElement
+    {
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        private Container directionContainer;
+        private Sprite noteSprite;
+
+        public LegacyNotePiece()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin, IScrollingInfo scrollingInfo)
+        {
+            InternalChild = directionContainer = new Container
+            {
+                Origin = Anchor.BottomCentre,
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Child = noteSprite = new Sprite { Texture = GetTexture(skin) }
+            };
+
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(OnDirectionChanged, true);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (noteSprite.Texture != null)
+            {
+                var scale = DrawWidth / noteSprite.Texture.DisplayWidth;
+                noteSprite.Scale = new Vector2(scale);
+            }
+        }
+
+        protected virtual void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            if (direction.NewValue == ScrollingDirection.Up)
+            {
+                directionContainer.Anchor = Anchor.TopCentre;
+                directionContainer.Scale = new Vector2(1, -1);
+            }
+            else
+            {
+                directionContainer.Anchor = Anchor.BottomCentre;
+                directionContainer.Scale = Vector2.One;
+            }
+        }
+
+        protected virtual Texture GetTexture(ISkinSource skin) => GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
+
+        protected Texture GetTextureFromLookup(ISkin skin, LegacyManiaSkinConfigurationLookups lookup)
+        {
+            string suffix = string.Empty;
+
+            switch (lookup)
+            {
+                case LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage:
+                    suffix = "H";
+                    break;
+
+                case LegacyManiaSkinConfigurationLookups.HoldNoteTailImage:
+                    suffix = "T";
+                    break;
+            }
+
+            string noteImage = skin.GetConfig<LegacyManiaSkinConfigurationLookup, string>(
+                                   new LegacyManiaSkinConfigurationLookup(Stage?.Columns.Count ?? 4, lookup, Column.Index))?.Value
+                               ?? $"mania-note{FallbackColumnIndex}{suffix}";
+
+            return skin.GetTexture(noteImage);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Skinning/ManiaLegacySkinTransformer.cs

@@ -44,11 +44,23 @@ namespace osu.Game.Rulesets.Mania.Skinning
 
                     switch (maniaComponent.Component)
                     {
+                        case ManiaSkinComponents.ColumnBackground:
+                            return new LegacyColumnBackground();
+
+                        case ManiaSkinComponents.HitTarget:
+                            return new LegacyHitTarget();
+
                         case ManiaSkinComponents.KeyArea:
                             return new LegacyKeyArea();
 
-                        case ManiaSkinComponents.ColumnBackground:
+                        case ManiaSkinComponents.Note:
-                            return new LegacyColumnBackground();
+                            return new LegacyNotePiece();
+
+                        case ManiaSkinComponents.HoldNoteHead:
+                            return new LegacyHoldNoteHeadPiece();
+
+                        case ManiaSkinComponents.HoldNoteTail:
+                            return new LegacyHoldNoteTailPiece();
                     }
 
                     break;

osu.Game.Rulesets.Mania/UI/Column.cs

@@ -12,7 +12,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
@@ -37,8 +36,6 @@ namespace osu.Game.Rulesets.Mania.UI
 
         internal readonly Container TopLevelContainer;
 
-        private readonly Container explosionContainer;
-
         public Column(int index)
         {
             Index = index;
@@ -51,29 +48,11 @@ namespace osu.Game.Rulesets.Mania.UI
                 RelativeSizeAxes = Axes.Both
             };
 
-            Container hitTargetContainer;
-
             InternalChildren = new[]
             {
                 // For input purposes, the background is added at the highest depth, but is then proxied back below all other elements
                 background.CreateProxy(),
-                hitTargetContainer = new Container
+                hitObjectArea = new ColumnHitObjectArea(HitObjectContainer) { RelativeSizeAxes = Axes.Both },
-                {
-                    Name = "Hit target + hit objects",
-                    RelativeSizeAxes = Axes.Both,
-                    Children = new Drawable[]
-                    {
-                        hitObjectArea = new ColumnHitObjectArea(HitObjectContainer)
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                        },
-                        explosionContainer = new Container
-                        {
-                            Name = "Hit explosions",
-                            RelativeSizeAxes = Axes.Both,
-                        }
-                    }
-                },
                 new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea), _ => new DefaultKeyArea())
                 {
                     RelativeSizeAxes = Axes.Both
@@ -82,22 +61,7 @@ namespace osu.Game.Rulesets.Mania.UI
                 TopLevelContainer = new Container { RelativeSizeAxes = Axes.Both }
             };
 
-            TopLevelContainer.Add(explosionContainer.CreateProxy());
+            TopLevelContainer.Add(hitObjectArea.Explosions.CreateProxy());
-
-            Direction.BindValueChanged(dir =>
-            {
-                hitTargetContainer.Padding = new MarginPadding
-                {
-                    Top = dir.NewValue == ScrollingDirection.Up ? ManiaStage.HIT_TARGET_POSITION : 0,
-                    Bottom = dir.NewValue == ScrollingDirection.Down ? ManiaStage.HIT_TARGET_POSITION : 0,
-                };
-
-                explosionContainer.Padding = new MarginPadding
-                {
-                    Top = dir.NewValue == ScrollingDirection.Up ? NotePiece.NOTE_HEIGHT / 2 : 0,
-                    Bottom = dir.NewValue == ScrollingDirection.Down ? NotePiece.NOTE_HEIGHT / 2 : 0
-                };
-            }, true);
         }
 
         public override Axes RelativeSizeAxes => Axes.Y;
@@ -118,21 +82,7 @@ namespace osu.Game.Rulesets.Mania.UI
             }
         }
 
-        private Color4 accentColour;
+        public Color4 AccentColour { get; set; }
-
-        public Color4 AccentColour
-        {
-            get => accentColour;
-            set
-            {
-                if (accentColour == value)
-                    return;
-
-                accentColour = value;
-
-                hitObjectArea.AccentColour = value;
-            }
-        }
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
@@ -167,7 +117,7 @@ namespace osu.Game.Rulesets.Mania.UI
             if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 
-            explosionContainer.Add(new HitExplosion(judgedObject.AccentColour.Value, judgedObject is DrawableHoldNoteTick)
+            hitObjectArea.Explosions.Add(new HitExplosion(judgedObject.AccentColour.Value, judgedObject is DrawableHoldNoteTick)
             {
                 Anchor = Direction.Value == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre,
                 Origin = Anchor.Centre

osu.Game.Rulesets.Mania/UI/Components/ColumnHitObjectArea.cs

@@ -3,34 +3,35 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Effects;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using osuTK.Graphics;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Mania.UI.Components
 {
-    public class ColumnHitObjectArea : CompositeDrawable, IHasAccentColour
+    public class ColumnHitObjectArea : SkinReloadableDrawable
     {
-        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+        public readonly Container<HitExplosion> Explosions;
 
+        [Resolved(CanBeNull = true)]
+        private ManiaStage stage { get; set; }
+
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
         private readonly Drawable hitTarget;
 
         public ColumnHitObjectArea(HitObjectContainer hitObjectContainer)
         {
             InternalChildren = new[]
             {
-                hitTarget = new DefaultHitTarget
+                hitTarget = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HitTarget), _ => new DefaultHitTarget())
                 {
                     RelativeSizeAxes = Axes.X,
                 },
-                hitObjectContainer
+                hitObjectContainer,
+                Explosions = new Container<HitExplosion> { RelativeSizeAxes = Axes.Both }
             };
         }
 
@@ -38,107 +39,39 @@ namespace osu.Game.Rulesets.Mania.UI.Components
         private void load(IScrollingInfo scrollingInfo)
         {
             direction.BindTo(scrollingInfo.Direction);
-            direction.BindValueChanged(dir =>
+            direction.BindValueChanged(onDirectionChanged, true);
-            {
-                Anchor anchor = dir.NewValue == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
-
-                hitTarget.Anchor = hitTarget.Origin = anchor;
-            }, true);
         }
 
-        private Color4 accentColour;
+        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
-
-        public Color4 AccentColour
         {
-            get => accentColour;
+            base.SkinChanged(skin, allowFallback);
-            set
+            updateHitPosition();
-            {
-                if (accentColour == value)
-                    return;
-
-                accentColour = value;
-
-                if (hitTarget is IHasAccentColour colouredHitTarget)
-                    colouredHitTarget.AccentColour = accentColour;
-            }
         }
 
-        private class DefaultHitTarget : CompositeDrawable, IHasAccentColour
+        private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
         {
-            private const float hit_target_bar_height = 2;
+            updateHitPosition();
+        }
 
-            private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+        private void updateHitPosition()
+        {
+            float hitPosition = CurrentSkin.GetConfig<LegacyManiaSkinConfigurationLookup, float>(
+                                    new LegacyManiaSkinConfigurationLookup(stage?.Columns.Count ?? 4, LegacyManiaSkinConfigurationLookups.HitPosition))?.Value
+                                ?? ManiaStage.HIT_TARGET_POSITION;
 
-            private readonly Container hitTargetLine;
+            if (direction.Value == ScrollingDirection.Up)
-            private readonly Drawable hitTargetBar;
-
-            public DefaultHitTarget()
             {
-                InternalChildren = new[]
+                hitTarget.Anchor = hitTarget.Origin = Anchor.TopLeft;
-                {
+
-                    hitTargetBar = new Box
+                Padding = new MarginPadding { Top = hitPosition };
-                    {
+                Explosions.Padding = new MarginPadding { Top = DefaultNotePiece.NOTE_HEIGHT };
-                        RelativeSizeAxes = Axes.X,
-                        Height = NotePiece.NOTE_HEIGHT,
-                        Alpha = 0.6f,
-                        Colour = Color4.Black
-                    },
-                    hitTargetLine = new Container
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Height = hit_target_bar_height,
-                        Masking = true,
-                        Child = new Box { RelativeSizeAxes = Axes.Both }
-                    },
-                };
             }
-
+            else
-            [BackgroundDependencyLoader]
-            private void load(IScrollingInfo scrollingInfo)
             {
-                direction.BindTo(scrollingInfo.Direction);
+                hitTarget.Anchor = hitTarget.Origin = Anchor.BottomLeft;
-                direction.BindValueChanged(dir =>
-                {
-                    Anchor anchor = dir.NewValue == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
 
-                    hitTargetBar.Anchor = hitTargetBar.Origin = anchor;
+                Padding = new MarginPadding { Bottom = hitPosition };
-                    hitTargetLine.Anchor = hitTargetLine.Origin = anchor;
+                Explosions.Padding = new MarginPadding { Bottom = DefaultNotePiece.NOTE_HEIGHT };
-                }, true);
-            }
-
-            protected override void LoadComplete()
-            {
-                base.LoadComplete();
-                updateColours();
-            }
-
-            private Color4 accentColour;
-
-            public Color4 AccentColour
-            {
-                get => accentColour;
-                set
-                {
-                    if (accentColour == value)
-                        return;
-
-                    accentColour = value;
-
-                    updateColours();
-                }
-            }
-
-            private void updateColours()
-            {
-                if (!IsLoaded)
-                    return;
-
-                hitTargetLine.EdgeEffect = new EdgeEffectParameters
-                {
-                    Type = EdgeEffectType.Glow,
-                    Radius = 5,
-                    Colour = accentColour.Opacity(0.5f),
-                };
             }
         }
     }

osu.Game.Rulesets.Mania/UI/Components/DefaultHitTarget.cs

@@ -0,0 +1,80 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.UI.Components
+{
+    public class DefaultHitTarget : CompositeDrawable
+    {
+        private const float hit_target_bar_height = 2;
+
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        private Container hitTargetLine;
+        private Drawable hitTargetBar;
+
+        [Resolved]
+        private Column column { get; set; }
+
+        public DefaultHitTarget()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            InternalChildren = new[]
+            {
+                hitTargetBar = new Box
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = DefaultNotePiece.NOTE_HEIGHT,
+                    Alpha = 0.6f,
+                    Colour = Color4.Black
+                },
+                hitTargetLine = new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = hit_target_bar_height,
+                    Masking = true,
+                    Child = new Box { RelativeSizeAxes = Axes.Both }
+                },
+            };
+
+            hitTargetLine.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Radius = 5,
+                Colour = column.AccentColour.Opacity(0.5f),
+            };
+
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(onDirectionChanged, true);
+        }
+
+        private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            if (direction.NewValue == ScrollingDirection.Up)
+            {
+                hitTargetBar.Anchor = hitTargetBar.Origin = Anchor.TopLeft;
+                hitTargetLine.Anchor = hitTargetLine.Origin = Anchor.TopLeft;
+            }
+            else
+            {
+                hitTargetBar.Anchor = hitTargetBar.Origin = Anchor.BottomLeft;
+                hitTargetLine.Anchor = hitTargetLine.Origin = Anchor.BottomLeft;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Mania/UI/HitExplosion.cs

@@ -12,7 +12,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    internal class HitExplosion : CompositeDrawable
+    public class HitExplosion : CompositeDrawable
     {
         public override bool RemoveWhenNotAlive => true;
 
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.UI
         public HitExplosion(Color4 objectColour, bool isSmall = false)
         {
             RelativeSizeAxes = Axes.X;
-            Height = NotePiece.NOTE_HEIGHT;
+            Height = DefaultNotePiece.NOTE_HEIGHT;
 
             // scale roughly in-line with visual appearance of notes
             Scale = new Vector2(1f, 0.6f);

osu.Game/Skinning/LegacyManiaSkinConfiguration.cs

@@ -14,6 +14,7 @@ namespace osu.Game.Skinning
         public readonly float[] ColumnWidth;
 
         public float HitPosition = 124.8f; // (480 - 402) * 1.6f
+        public bool ShowJudgementLine = true;
 
         public LegacyManiaSkinConfiguration(int keys)
         {

osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs

@@ -19,10 +19,16 @@ namespace osu.Game.Skinning
 
     public enum LegacyManiaSkinConfigurationLookups
     {
-        KeyImage,
-        KeyImageDown,
         LightImage,
         LeftLineWidth,
-        RightLineWidth
+        RightLineWidth,
+        HitPosition,
+        HitTargetImage,
+        ShowJudgementLine,
+        KeyImage,
+        KeyImageDown,
+        NoteImage,
+        HoldNoteHeadImage,
+        HoldNoteTailImage
     }
 }

osu.Game/Skinning/LegacyManiaSkinDecoder.cs

@@ -90,6 +90,10 @@ namespace osu.Game.Skinning
                     case "HitPosition":
                         currentConfig.HitPosition = (480 - float.Parse(pair.Value, CultureInfo.InvariantCulture)) * size_scale_factor;
                         break;
+
+                    case "JudgementLine":
+                        currentConfig.ShowJudgementLine = pair.Value == "1";
+                        break;
                 }
             }
         }

osu.Game/Skinning/LegacySkin.cs

@@ -124,8 +124,17 @@ namespace osu.Game.Skinning
                     if (!AllowManiaSkin)
                         return null;
 
-                    if (!maniaConfigurations.TryGetValue(legacy.Keys, out _))
+                    if (!maniaConfigurations.TryGetValue(legacy.Keys, out var existing))
-                        maniaConfigurations[legacy.Keys] = new LegacyManiaSkinConfiguration(legacy.Keys);
+                        maniaConfigurations[legacy.Keys] = existing = new LegacyManiaSkinConfiguration(legacy.Keys);
+
+                    switch (legacy.Lookup)
+                    {
+                        case LegacyManiaSkinConfigurationLookups.HitPosition:
+                            return SkinUtils.As<TValue>(new Bindable<float>(existing.HitPosition));
+
+                        case LegacyManiaSkinConfigurationLookups.ShowJudgementLine:
+                            return SkinUtils.As<TValue>(new Bindable<bool>(existing.ShowJudgementLine));
+                    }
 
                     break;
 

osu.Game/Skinning/SkinnableDrawable.cs

@@ -18,6 +18,12 @@ namespace osu.Game.Skinning
         /// </summary>
         public Drawable Drawable { get; private set; }
 
+        public new Axes AutoSizeAxes
+        {
+            get => base.AutoSizeAxes;
+            set => base.AutoSizeAxes = value;
+        }
+
         private readonly ISkinComponent component;
 
         private readonly ConfineMode confineMode;