Add osu!taiko legacy drum skinning support

osu.Game.Rulesets.Taiko.Tests/TestSceneInputDrum.cs

@@ -4,31 +4,28 @@
 using System;
 using System.Collections.Generic;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Taiko.Audio;
 using osu.Game.Rulesets.Taiko.UI;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
     [TestFixture]
-    public class TestSceneInputDrum : OsuTestScene
+    public class TestSceneInputDrum : SkinnableTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(InputDrum),
-            typeof(DrumSampleMapping),
-            typeof(HitSampleInfo),
-            typeof(SampleControlPoint)
         };
 
-        public TestSceneInputDrum()
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            Add(new TaikoInputManager(new RulesetInfo { ID = 1 })
+            SetContents(() => new TaikoInputManager(new RulesetInfo { ID = 1 })
             {
                 RelativeSizeAxes = Axes.Both,
                 Child = new Container

osu.Game.Rulesets.Taiko/Skinning/LegacyTaikoDrum.cs

@@ -0,0 +1,144 @@
+// 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 System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.Taiko.Audio;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Taiko.Skinning
+{
+    /// <summary>
+    /// A component of the playfield that captures input and displays input as a drum.
+    /// </summary>
+    internal class LegacyInputDrum : Container
+    {
+        public LegacyInputDrum()
+        {
+            AutoSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
+        {
+            Children = new Drawable[]
+            {
+                new Sprite
+                {
+                    Texture = skin.GetTexture("taiko-bar-left")
+                },
+                new LegacyHalfDrum(false)
+                {
+                    Name = "Left Half",
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 0.5f,
+                    RimAction = TaikoAction.LeftRim,
+                    CentreAction = TaikoAction.LeftCentre
+                },
+                new LegacyHalfDrum(true)
+                {
+                    Name = "Right Half",
+                    Anchor = Anchor.TopRight,
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 0.5f,
+                    Scale = new Vector2(-1, 1),
+                    RimAction = TaikoAction.RightRim,
+                    CentreAction = TaikoAction.RightCentre
+                }
+            };
+        }
+
+        /// <summary>
+        /// A half-drum. Contains one centre and one rim hit.
+        /// </summary>
+        private class LegacyHalfDrum : Container, IKeyBindingHandler<TaikoAction>
+        {
+            /// <summary>
+            /// The key to be used for the rim of the half-drum.
+            /// </summary>
+            public TaikoAction RimAction;
+
+            /// <summary>
+            /// The key to be used for the centre of the half-drum.
+            /// </summary>
+            public TaikoAction CentreAction;
+
+            private readonly Sprite rimHit;
+            private readonly Sprite centreHit;
+
+            [Resolved]
+            private DrumSampleMapping sampleMappings { get; set; }
+
+            public LegacyHalfDrum(bool flipped)
+            {
+                Masking = true;
+
+                Children = new Drawable[]
+                {
+                    rimHit = new Sprite
+                    {
+                        Anchor = flipped ? Anchor.CentreRight : Anchor.CentreLeft,
+                        Origin = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
+                        Scale = new Vector2(-1, 1),
+                        Alpha = 0,
+                    },
+                    centreHit = new Sprite
+                    {
+                        Anchor = flipped ? Anchor.CentreRight : Anchor.CentreLeft,
+                        Origin = flipped ? Anchor.CentreRight : Anchor.CentreLeft,
+                        Alpha = 0,
+                    }
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(ISkinSource skin)
+            {
+                rimHit.Texture = skin.GetTexture(@"taiko-drum-outer");
+                centreHit.Texture = skin.GetTexture(@"taiko-drum-inner");
+            }
+
+            public bool OnPressed(TaikoAction action)
+            {
+                Drawable target = null;
+                var drumSample = sampleMappings.SampleAt(Time.Current);
+
+                if (action == CentreAction)
+                {
+                    target = centreHit;
+                    drumSample.Centre?.Play();
+                }
+                else if (action == RimAction)
+                {
+                    target = rimHit;
+                    drumSample.Rim?.Play();
+                }
+
+                if (target != null)
+                {
+                    const float alpha_amount = 1;
+
+                    const float down_time = 80;
+                    const float up_time = 50;
+
+                    target.Animate(
+                        t => t.FadeTo(Math.Min(target.Alpha + alpha_amount, 1), down_time)
+                    ).Then(
+                        t => t.FadeOut(up_time)
+                    );
+                }
+
+                return false;
+            }
+
+            public void OnReleased(TaikoAction action)
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Skinning/TaikoLegacySkinTransformer.cs

@@ -20,7 +20,22 @@ namespace osu.Game.Rulesets.Taiko.Skinning
             this.source = source;
         }
 
-        public Drawable GetDrawableComponent(ISkinComponent component) => source.GetDrawableComponent(component);
+        public Drawable GetDrawableComponent(ISkinComponent component)
+        {
+            if (!(component is TaikoSkinComponent taikoComponent))
+                return null;
+
+            switch (taikoComponent.Component)
+            {
+                case TaikoSkinComponents.InputDrum:
+                    if (GetTexture("taiko-bar-left") != null)
+                        return new LegacyInputDrum();
+
+                    return null;
+            }
+
+            return source.GetDrawableComponent(component);
+        }
 
         public Texture GetTexture(string componentName) => source.GetTexture(componentName);
 

osu.Game.Rulesets.Taiko/TaikoSkinComponents.cs

@@ -5,5 +5,6 @@ namespace osu.Game.Rulesets.Taiko
 {
     public enum TaikoSkinComponents
     {
+        InputDrum,
     }
 }

osu.Game.Rulesets.Taiko/UI/InputDrum.cs

@@ -12,6 +12,7 @@ using osu.Framework.Input.Bindings;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Audio;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
@@ -22,11 +23,12 @@ namespace osu.Game.Rulesets.Taiko.UI
     {
         private const float middle_split = 0.025f;
 
-        private readonly ControlPointInfo controlPoints;
+        [Cached]
+        private DrumSampleMapping sampleMapping;
 
         public InputDrum(ControlPointInfo controlPoints)
         {
-            this.controlPoints = controlPoints;
+            sampleMapping = new DrumSampleMapping(controlPoints);
 
             RelativeSizeAxes = Axes.Both;
             FillMode = FillMode.Fit;
@@ -35,11 +37,12 @@ namespace osu.Game.Rulesets.Taiko.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            var sampleMappings = new DrumSampleMapping(controlPoints);
+            Child = new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.InputDrum), _ => new Container
-
+            {
+                RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
                 {
-                new TaikoHalfDrum(false, sampleMappings)
+                    new TaikoHalfDrum(false)
                     {
                         Name = "Left Half",
                         Anchor = Anchor.Centre,
@@ -50,7 +53,7 @@ namespace osu.Game.Rulesets.Taiko.UI
                         RimAction = TaikoAction.LeftRim,
                         CentreAction = TaikoAction.LeftCentre
                     },
-                new TaikoHalfDrum(true, sampleMappings)
+                    new TaikoHalfDrum(true)
                     {
                         Name = "Right Half",
                         Anchor = Anchor.Centre,
@@ -61,9 +64,10 @@ namespace osu.Game.Rulesets.Taiko.UI
                         RimAction = TaikoAction.RightRim,
                         CentreAction = TaikoAction.RightCentre
                     }
-            };
+                }
+            });
 
-            AddRangeInternal(sampleMappings.Sounds);
+            AddRangeInternal(sampleMapping.Sounds);
         }
 
         /// <summary>
@@ -86,12 +90,11 @@ namespace osu.Game.Rulesets.Taiko.UI
             private readonly Sprite centre;
             private readonly Sprite centreHit;
 
-            private readonly DrumSampleMapping sampleMappings;
+            [Resolved]
+            private DrumSampleMapping sampleMappings { get; set; }
 
-            public TaikoHalfDrum(bool flipped, DrumSampleMapping sampleMappings)
+            public TaikoHalfDrum(bool flipped)
             {
-                this.sampleMappings = sampleMappings;
-
                 Masking = true;
 
                 Children = new Drawable[]