Merge remote-tracking branch 'origin/master' into glwrapper-depthinfo

# Conflicts:
# osu.Framework/Graphics/OpenGL/GLWrapper.cs

osu.Framework/Graphics/Colour/ColourInfo.cs

···
             get
             {
                 float max = TopLeft.Linear.A;
-                if (TopRight.Linear.A < max) max = TopRight.Linear.A;
-                if (BottomLeft.Linear.A < max) max = BottomLeft.Linear.A;
-                if (BottomRight.Linear.A < max) max = BottomRight.Linear.A;
+                if (TopRight.Linear.A > max) max = TopRight.Linear.A;
+                if (BottomLeft.Linear.A > max) max = BottomLeft.Linear.A;
+                if (BottomRight.Linear.A > max) max = BottomRight.Linear.A;
 
                 return max;
+            }
+        }
+
+        /// <summary>
+        /// The minimum alpha value of all four corners.
+        /// </summary>
+        public float MinAlpha
+        {
+            get
+            {
+                float min = TopLeft.Linear.A;
+                if (TopRight.Linear.A < min) min = TopRight.Linear.A;
+                if (BottomLeft.Linear.A < min) min = BottomLeft.Linear.A;
+                if (BottomRight.Linear.A < min) min = BottomRight.Linear.A;
+
+                return min;
             }
         }
 

osu.Framework/Graphics/Containers/BufferedContainerDrawNode.cs

···
                 // We can do this by adding a translation component to our (orthogonal) projection matrix.
                 GLWrapper.PushOrtho(ScreenSpaceDrawRectangle);
 
-                GLWrapper.ClearColour(BackgroundColour);
+                GLWrapper.Clear(new ClearInfo(BackgroundColour));
                 base.Draw(vertexAction);
 
                 GLWrapper.PopOrtho();

osu.Framework/Graphics/OpenGL/ClearInfo.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osuTK.Graphics;
+
+namespace osu.Framework.Graphics.OpenGL
+{
+    /// <summary>
+    /// Information for how the current frame buffer should be cleared.
+    /// </summary>
+    public readonly struct ClearInfo
+    {
+        /// <summary>
+        /// The default clear properties, as defined by OpenGL.
+        /// </summary>
+        public static ClearInfo Default => new ClearInfo(default);
+
+        /// <summary>
+        /// The colour to write to the frame buffer.
+        /// </summary>
+        public readonly Color4 Colour;
+
+        /// <summary>
+        /// The depth to write to the frame buffer.
+        /// </summary>
+        public readonly double Depth;
+
+        /// <summary>
+        /// The stencil value to write to the frame buffer.
+        /// </summary>
+        public readonly int Stencil;
+
+        public ClearInfo(Color4 colour = default, double depth = 1f, int stencil = 0)
+        {
+            Colour = colour;
+            Depth = depth;
+            Stencil = stencil;
+        }
+    }
+}

osu.Framework/Graphics/OpenGL/GLWrapper.cs

···
             }, true);
 
             PushDepthInfo(new DepthInfo(false));
+            Clear(ClearInfo.Default);
         }
 
-        // We initialize to an invalid value such that we are not missing an initial GL.ClearColor call.
-        private static Color4 clearColour = new Color4(-1, -1, -1, -1);
+        private static ClearInfo currentClearInfo;
 
-        public static void ClearColour(Color4 c)
+        public static void Clear(ClearInfo clearInfo)
         {
-            if (clearColour != c)
+            if (clearInfo.Colour != currentClearInfo.Colour)
+                GL.ClearColor(clearInfo.Colour);
+
+            if (clearInfo.Depth != currentClearInfo.Depth)
             {
-                clearColour = c;
-                GL.ClearColor(clearColour);
+                // Todo: Wtf. osuTK's bindings are broken for glClearDepthf(). Using glClearDepth() for now
+                osuTK.Graphics.OpenGL.GL.ClearDepth(clearInfo.Depth);
             }
 
+            if (clearInfo.Stencil != currentClearInfo.Stencil)
+                GL.ClearStencil(clearInfo.Stencil);
+
             GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit);
+
+            currentClearInfo = clearInfo;
         }
 
         /// <summary>

osu.Framework/Platform/GameHost.cs

···
             setVSyncMode();
 
             GLWrapper.Reset(new Vector2(Window.ClientSize.Width, Window.ClientSize.Height));
-            GLWrapper.ClearColour(Color4.Black);
+            GLWrapper.Clear(ClearInfo.Default);
         }
 
         private long lastDrawFrameId;
···
                     using (drawMonitor.BeginCollecting(PerformanceCollectionType.GLReset))
                     {
                         GLWrapper.Reset(new Vector2(Window.ClientSize.Width, Window.ClientSize.Height));
-                        GLWrapper.ClearColour(Color4.Black);
+                        GLWrapper.Clear(ClearInfo.Default);
                     }
 
                     buffer.Object.Draw(null);

osu.Framework/Testing/Drawables/TestCaseButton.cs

···
             : this()
         {
             TestType = test;
-            text.AddText(test.Name.Replace("TestCase", ""));
+            text.AddText(TestCase.RemovePrefix(test.Name));
 
             var description = test.GetCustomAttribute<DescriptionAttribute>()?.Description;
             if (description != null)

osu.Framework/Testing/Drawables/TestCaseButtonGroup.cs

···
             bool hasHeader = tests.Length > 1;
 
             if (hasHeader)
-                buttonFlow.Add(headerButton = new TestCaseHeaderButton(group.Name.Replace("TestCase", ""))
+                buttonFlow.Add(headerButton = new TestCaseHeaderButton(group.Name)
                 {
                     Action = ToggleVisibility
                 });
···
 
         protected override void PopIn() => buttonFlow.ForEach(b => b.Collapsed = false);
 
-        protected override void PopOut() => buttonFlow.ForEach(b => b.Collapsed = true);
+        protected override void PopOut()
+        {
+            if (headerButton != null)
+                buttonFlow.ForEach(b => b.Collapsed = true);
+        }
     }
 }

osu.Framework/Testing/DynamicClassCompiler.cs

···
                 // add ourselves as a required type.
                 reqTypes.Add(checkpointName);
                 // if we are a TestCase, add the class we are testing automatically.
-                reqTypes.Add(checkpointName.Replace("TestCase", ""));
+                reqTypes.Add(TestCase.RemovePrefix(checkpointName));
 
                 if (!reqTypes.Contains(Path.GetFileNameWithoutExtension(e.Name)))
                     return;

osu.Framework/Testing/TestBrowser.cs

···
         private void updateList(ValueChangedEvent<Assembly> args)
         {
             leftFlowContainer.Clear();
+
             //Add buttons for each TestCase.
             string namespacePrefix = TestTypes.Select(t => t.Namespace).GetCommonPrefix();
 
···
                                                     t =>
                                                     {
                                                         string group = t.Namespace?.Substring(namespacePrefix.Length).TrimStart('.');
-                                                        return string.IsNullOrWhiteSpace(group) ? t.Name : group;
+                                                        return string.IsNullOrWhiteSpace(group) ? TestCase.RemovePrefix(t.Name) : group;
                                                     },
                                                     t => t,
                                                     (group, types) => new TestGroup { Name = group, TestTypes = types.ToArray() }
-                                                ).Select(t => new TestCaseButtonGroup(type => LoadTest(type), t)));
+                                                ).OrderBy(g => g.Name)
+                                                .Select(t => new TestCaseButtonGroup(type => LoadTest(type), t)));
         }
 
         internal readonly BindableDouble PlaybackRate = new BindableDouble(1) { MinValue = 0, MaxValue = 2 };
···
                 if (!interactive || RunAllSteps.Value)
                     return false;
 
+                if (actualStepCount > 0)
+                    // stop once one actual step has been run.
+                    return true;
+
                 if (!(s is SetUpStep) && !(s is LabelStep))
                     actualStepCount++;
 
-                return actualStepCount > 1;
+                return false;
             });
         }
 

osu.Framework/Testing/TestCase.cs

···
         }
 
         /// <summary>
-        /// Most derived usages of this start with TestCase. This will be removed for display purposes.
-        /// </summary>
-        private const string prefix = "TestCase";
-
-        /// <summary>
         /// Tests any steps and assertions in the constructor of this <see cref="TestCase"/>.
         /// This test must run before any other tests, as it relies on <see cref="StepsContainer"/> not being cleared and not having any elements.
         /// </summary>
···
 
         protected TestCase()
         {
-            Name = GetType().ReadableName();
-
-            // Skip the "TestCase" prefix
-            if (Name.StartsWith(prefix)) Name = Name.Replace(prefix, string.Empty);
+            Name = RemovePrefix(GetType().ReadableName());
 
             RelativeSizeAxes = Axes.Both;
             Masking = true;
···
             foreach (var method in GetType().GetMethods().Where(m => m.GetCustomAttributes(typeof(SetUpStepsAttribute), false).Length > 0))
                 method.Invoke(this, null);
         }
+
+        /// <summary>
+        /// Remove the "TestCase" prefix from a name.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public static string RemovePrefix(string name) => name.Replace(nameof(TestCase), string.Empty);
     }
 }