Merge pull request #9945 from smoogipoo/skin-colour-fix-2

Exactly reproduce osu!stable skin colour alphas

osu.Game.Rulesets.Catch/Skinning/CatchLegacySkinTransformer.cs

@@ -6,6 +6,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Skinning;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Skinning
 {
@@ -61,7 +62,12 @@ namespace osu.Game.Rulesets.Catch.Skinning
             switch (lookup)
             {
                 case CatchSkinColour colour:
-                    return Source.GetConfig<SkinCustomColourLookup, TValue>(new SkinCustomColourLookup(colour));
+                    var result = (Bindable<Color4>)Source.GetConfig<SkinCustomColourLookup, TValue>(new SkinCustomColourLookup(colour));
+                    if (result == null)
+                        return null;
+
+                    result.Value = LegacyColourCompatibility.DisallowZeroAlpha(result.Value);
+                    return (IBindable<TValue>)result;
             }
 
             return Source.GetConfig<TLookup, TValue>(lookup);

osu.Game.Rulesets.Catch/Skinning/LegacyFruitPiece.cs

@@ -40,7 +40,6 @@ namespace osu.Game.Rulesets.Catch.Skinning
                 colouredSprite = new Sprite
                 {
                     Texture = skin.GetTexture(lookupName),
-                    Colour = drawableObject.AccentColour.Value,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                 },
@@ -76,7 +75,7 @@ namespace osu.Game.Rulesets.Catch.Skinning
         {
             base.LoadComplete();
 
-            accentColour.BindValueChanged(colour => colouredSprite.Colour = colour.NewValue, true);
+            accentColour.BindValueChanged(colour => colouredSprite.Colour = LegacyColourCompatibility.DisallowZeroAlpha(colour.NewValue), true);
         }
     }
 }

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

@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
                     {
                         Anchor = Anchor.BottomCentre,
                         Origin = Anchor.BottomCentre,
-                        Colour = lightColour,
+                        Colour = LegacyColourCompatibility.DisallowZeroAlpha(lightColour),
                         Texture = skin.GetTexture(lightImage),
                         RelativeSizeAxes = Axes.X,
                         Width = 1,

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

@@ -51,7 +51,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
                         Anchor = Anchor.CentreLeft,
                         RelativeSizeAxes = Axes.X,
                         Height = 1,
-                        Colour = lineColour,
+                        Colour = LegacyColourCompatibility.DisallowZeroAlpha(lineColour),
                         Alpha = showJudgementLine ? 0.9f : 0
                     }
                 }

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

@@ -106,37 +106,38 @@ namespace osu.Game.Rulesets.Mania.Skinning
 
                 InternalChildren = new Drawable[]
                 {
-                    new Container
+                    LegacyColourCompatibility.ApplyWithDoubledAlpha(new Box
                     {
-                        RelativeSizeAxes = Axes.Both,
+                        RelativeSizeAxes = Axes.Both
-                        Child = new Box
+                    }, backgroundColour),
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = backgroundColour
-                        },
-                    },
                     new HitTargetInsetContainer
                     {
                         RelativeSizeAxes = Axes.Both,
                         Children = new[]
                         {
-                            new Box
+                            new Container
                             {
                                 RelativeSizeAxes = Axes.Y,
                                 Width = leftLineWidth,
                                 Scale = new Vector2(0.740f, 1),
-                                Colour = lineColour,
+                                Alpha = hasLeftLine ? 1 : 0,
-                                Alpha = hasLeftLine ? 1 : 0
+                                Child = LegacyColourCompatibility.ApplyWithDoubledAlpha(new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both
+                                }, lineColour)
                             },
-                            new Box
+                            new Container
                             {
                                 Anchor = Anchor.TopRight,
                                 Origin = Anchor.TopRight,
                                 RelativeSizeAxes = Axes.Y,
                                 Width = rightLineWidth,
                                 Scale = new Vector2(0.740f, 1),
-                                Colour = lineColour,
+                                Alpha = hasRightLine ? 1 : 0,
-                                Alpha = hasRightLine ? 1 : 0
+                                Child = LegacyColourCompatibility.ApplyWithDoubledAlpha(new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both
+                                }, lineColour)
                             },
                         }
                     }

osu.Game.Rulesets.Osu/Skinning/LegacyMainCirclePiece.cs

@@ -59,7 +59,6 @@ namespace osu.Game.Rulesets.Osu.Skinning
                         hitCircleSprite = new Sprite
                         {
                             Texture = getTextureWithFallback(string.Empty),
-                            Colour = drawableObject.AccentColour.Value,
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
                         },
@@ -107,7 +106,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
             base.LoadComplete();
 
             state.BindValueChanged(updateState, true);
-            accentColour.BindValueChanged(colour => hitCircleSprite.Colour = colour.NewValue, true);
+            accentColour.BindValueChanged(colour => hitCircleSprite.Colour = LegacyColourCompatibility.DisallowZeroAlpha(colour.NewValue), true);
             indexInCurrentCombo.BindValueChanged(index => hitCircleText.Text = (index.NewValue + 1).ToString(), true);
         }
 

osu.Game.Rulesets.Osu/Skinning/LegacySliderBall.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin, DrawableHitObject drawableObject)
         {
-            animationContent.Colour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBall)?.Value ?? Color4.White;
+            var ballColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBall)?.Value ?? Color4.White;
 
             InternalChildren = new[]
             {
@@ -39,11 +39,11 @@ namespace osu.Game.Rulesets.Osu.Skinning
                     Texture = skin.GetTexture("sliderb-nd"),
                     Colour = new Color4(5, 5, 5, 255),
                 },
-                animationContent.With(d =>
+                LegacyColourCompatibility.ApplyWithDoubledAlpha(animationContent.With(d =>
                 {
                     d.Anchor = Anchor.Centre;
                     d.Origin = Anchor.Centre;
-                }),
+                }), ballColour),
                 layerSpec = new Sprite
                 {
                     Anchor = Anchor.Centre,

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

@@ -90,7 +90,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning
 
         private void updateAccentColour()
         {
-            backgroundLayer.Colour = accentColour;
+            backgroundLayer.Colour = LegacyColourCompatibility.DisallowZeroAlpha(accentColour);
         }
     }
 }

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

@@ -76,9 +76,11 @@ namespace osu.Game.Rulesets.Taiko.Skinning
 
         private void updateAccentColour()
         {
-            headCircle.AccentColour = accentColour;
+            var colour = LegacyColourCompatibility.DisallowZeroAlpha(accentColour);
-            body.Colour = accentColour;
+
-            end.Colour = accentColour;
+            headCircle.AccentColour = colour;
+            body.Colour = colour;
+            end.Colour = colour;
         }
     }
 }

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Game.Skinning;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Taiko.Skinning
@@ -18,9 +19,10 @@ namespace osu.Game.Rulesets.Taiko.Skinning
         [BackgroundDependencyLoader]
         private void load()
         {
-            AccentColour = component == TaikoSkinComponents.CentreHit
+            AccentColour = LegacyColourCompatibility.DisallowZeroAlpha(
+                component == TaikoSkinComponents.CentreHit
                     ? new Color4(235, 69, 44, 255)
-                : new Color4(67, 142, 172, 255);
+                    : new Color4(67, 142, 172, 255));
         }
     }
 }

osu.Game.Tests/Resources/skin-zero-alpha-colour.ini

@@ -1,5 +0,0 @@
-[General]
-Version: latest
-
-[Colours]
-Combo1: 255,255,255,0

osu.Game.Tests/Skins/LegacySkinDecoderTest.cs

@@ -108,15 +108,5 @@ namespace osu.Game.Tests.Skins
             using (var stream = new LineBufferedReader(resStream))
                 Assert.That(decoder.Decode(stream).LegacyVersion, Is.EqualTo(1.0m));
         }
-
-        [Test]
-        public void TestDecodeColourWithZeroAlpha()
-        {
-            var decoder = new LegacySkinDecoder();
-
-            using (var resStream = TestResources.OpenResource("skin-zero-alpha-colour.ini"))
-            using (var stream = new LineBufferedReader(resStream))
-                Assert.That(decoder.Decode(stream).ComboColours[0].A, Is.EqualTo(1.0f));
-        }
     }
 }

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -104,10 +104,6 @@ namespace osu.Game.Beatmaps.Formats
             try
             {
                 byte alpha = split.Length == 4 ? byte.Parse(split[3]) : (byte)255;
-
-                if (alpha == 0)
-                    alpha = 255;
-
                 colour = new Color4(byte.Parse(split[0]), byte.Parse(split[1]), byte.Parse(split[2]), alpha);
             }
             catch

osu.Game/Skinning/LegacyColourCompatibility.cs

@@ -0,0 +1,46 @@
+// 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;
+using osuTK.Graphics;
+
+namespace osu.Game.Skinning
+{
+    /// <summary>
+    /// Compatibility methods to convert osu!stable colours to osu!lazer-compatible ones. Should be used for legacy skins only.
+    /// </summary>
+    public static class LegacyColourCompatibility
+    {
+        /// <summary>
+        /// Forces an alpha of 1 if a given <see cref="Color4"/> is fully transparent.
+        /// </summary>
+        /// <remarks>
+        /// This is equivalent to setting colour post-constructor in osu!stable.
+        /// </remarks>
+        /// <param name="colour">The <see cref="Color4"/> to disallow zero alpha on.</param>
+        /// <returns>The resultant <see cref="Color4"/>.</returns>
+        public static Color4 DisallowZeroAlpha(Color4 colour)
+        {
+            if (colour.A == 0)
+                colour.A = 1;
+            return colour;
+        }
+
+        /// <summary>
+        /// Applies a <see cref="Color4"/> to a <see cref="Drawable"/>, doubling the alpha value into the <see cref="Drawable.Alpha"/> property.
+        /// </summary>
+        /// <remarks>
+        /// This is equivalent to setting colour in the constructor in osu!stable.
+        /// </remarks>
+        /// <param name="drawable">The <see cref="Drawable"/> to apply the colour to.</param>
+        /// <param name="colour">The <see cref="Color4"/> to apply.</param>
+        /// <returns>The given <paramref name="drawable"/>.</returns>
+        public static T ApplyWithDoubledAlpha<T>(T drawable, Color4 colour)
+            where T : Drawable
+        {
+            drawable.Alpha = colour.A;
+            drawable.Colour = DisallowZeroAlpha(colour);
+            return drawable;
+        }
+    }
+}