Implement apple's "continuous curves"

osu.Framework.Tests/Visual/Containers/TestSceneMasking.cs

···
     public class TestSceneMasking : FrameworkTestScene
     {
         protected Container TestContainer;
+        protected int CurrentTest;
+        protected float TestCornerExponent = 2f;
 
         public TestSceneMasking()
         {
···
                 AddStep(testNames[i], delegate { loadTest(test); });
             }
 
+            AddSliderStep<float>("Corner exponent", 2, 5, 2, exponent =>
+            {
+                TestCornerExponent = exponent;
+                loadTest(CurrentTest);
+            });
+
             loadTest(0);
             addCrosshair();
         }
···
         private void loadTest(int testType)
         {
             TestContainer.Clear();
+            CurrentTest = testType;
 
             switch (testType)
             {
···
                         Origin = Anchor.Centre,
                         Masking = true,
                         CornerRadius = 100,
+                        CornerExponent = TestCornerExponent,
                         BorderColour = Color4.Aquamarine,
                         BorderThickness = 3,
                         EdgeEffect = new EdgeEffectParameters
···
                             {
                                 Masking = true,
                                 CornerRadius = 100,
+                                CornerExponent = TestCornerExponent,
                                 Size = new Vector2(400, 400),
                                 Alpha = 0.5f,
                                 Origin = Anchor.Centre,
···
                             {
                                 Masking = true,
                                 CornerRadius = 25,
+                                CornerExponent = TestCornerExponent,
                                 Shear = new Vector2(0.5f, 0),
                                 Size = new Vector2(150, 150),
                                 Scale = new Vector2(2.5f, 1.5f),
···
                             {
                                 Masking = true,
                                 CornerRadius = 25,
+                                CornerExponent = TestCornerExponent,
                                 Shear = new Vector2(0.5f, 0),
                                 Alpha = 0.5f,
                                 Origin = Anchor.Centre,
···
                                     {
                                         Masking = true,
                                         CornerRadius = 25,
+                                        CornerExponent = TestCornerExponent,
                                         Shear = new Vector2(0.25f, 0.25f),
                                         Size = new Vector2(100, 200),
                                         Alpha = 0.5f,
···
 
                 case 4:
                 {
-                    static Drawable createMaskingBox(float scale)
+                    static Drawable createMaskingBox(float scale, float testCornerExponent)
                     {
                         float size = 200 / scale;
                         return new Container
                         {
                             Masking = true,
                             CornerRadius = 25 / scale,
+                            CornerExponent = testCornerExponent,
                             BorderThickness = 12.5f / scale,
                             BorderColour = Color4.Red,
                             Size = new Vector2(size),
···
                                 RelativeSizeAxes = Axes.Both,
                                 Size = new Vector2(0.5f),
                                 Masking = true,
-                                Children = new[] { createMaskingBox(100) }
+                                Children = new[] { createMaskingBox(100, TestCornerExponent) }
                             },
                             new Container
                             {
                                 RelativeSizeAxes = Axes.Both,
                                 Size = new Vector2(0.5f),
                                 Masking = true,
-                                Children = new[] { createMaskingBox(10) }
+                                Children = new[] { createMaskingBox(10, TestCornerExponent) }
                             },
                             new Container
                             {
                                 RelativeSizeAxes = Axes.Both,
                                 Size = new Vector2(0.5f),
                                 Masking = true,
-                                Children = new[] { createMaskingBox(1) }
+                                Children = new[] { createMaskingBox(1, TestCornerExponent) }
                             },
                             new Container
                             {
                                 RelativeSizeAxes = Axes.Both,
                                 Size = new Vector2(0.5f),
                                 Masking = true,
-                                Children = new[] { createMaskingBox(0.1f) }
+                                Children = new[] { createMaskingBox(0.1f, TestCornerExponent) }
                             },
                         }
                     });
···
                             {
                                 Masking = true,
                                 CornerRadius = 100f,
+                                CornerExponent = TestCornerExponent,
                                 BorderThickness = 50f,
                                 BorderColour = Color4.Red,
                                 RelativeSizeAxes = Axes.Both,
···
                         Origin = Anchor.Centre,
                         Masking = true,
                         CornerRadius = 100,
+                        CornerExponent = TestCornerExponent,
                         Alpha = 0.8f,
                         EdgeEffect = new EdgeEffectParameters
                         {

osu.Framework.Tests/Visual/Input/TestSceneNestedHover.cs

···
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-                Size = new Vector2(300, 300)
+                Size = new Vector2(300, 300),
+                CornerRadius = 100,
+                CornerExponent = 5,
+                Masking = true,
             });
 
             HoverBox box2;

osu.Framework/Graphics/Containers/CircularContainer.cs

···
 namespace osu.Framework.Graphics.Containers
 {
     /// <summary>
-    /// A container which is rounded (via automatic corner-radius) on the shortest edge.
+    /// A container which is rounded (via automatic corner-radius and corner-exponent=2) on the shortest edge.
     /// </summary>
     public class CircularContainer : Container
     {
···
             // this shouldn't have to be done here, but it's the only place it works correctly.
             // see https://github.com/ppy/osu-framework/pull/1666
             CornerRadius = Math.Min(DrawSize.X, DrawSize.Y) / 2f;
+            CornerExponent = 2;
 
             return base.GenerateDrawNodeSubtree(frame, treeIndex, forceNewDrawNode);
         }

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
 
         public override bool Contains(Vector2 screenSpacePos)
         {
-            float cRadius = CornerRadius;
+            float cRadius = effectiveCornerRadius;
+            float cExponent = CornerExponent;
 
             // Select a cheaper contains method when we don't need rounded edges.
             if (cRadius == 0.0f)
                 return base.Contains(screenSpacePos);
 
-            return DrawRectangle.Shrink(cRadius).DistanceSquared(ToLocalSpace(screenSpacePos)) <= cRadius * cRadius;
+            return DrawRectangle.Shrink(cRadius).DistanceExponentiated(ToLocalSpace(screenSpacePos), cExponent) <= Math.Pow(cRadius, cExponent);
         }
 
         /// <summary>
···
             }
         }
 
+        private float cornerExponent = 2.5f;
+
+        /// <summary>
+        /// Determines how gentle the curve of the corner straightens. A value of 2 results in
+        /// circular arcs, a value of 2.5 (default) results in something closer to apple's "continuous curve".
+        /// Recommended range: 2--5. Values outside of that range may result in unpredictable behavior.
+        /// Only has an effect when <see cref="Masking"/> is true and <see cref="CornerRadius"/> is non-zero.
+        /// </summary>
+        public float CornerExponent
+        {
+            get => cornerExponent;
+            protected set
+            {
+                if (cornerExponent == value)
+                    return;
+
+                cornerExponent = value;
+                Invalidate(Invalidation.DrawNode);
+            }
+        }
+
+        // This _hacky_ modification of the corner radius (obtained from playing around) ensures that the corner remains at roughly
+        // equal size (perceptually) compared to the circular arc as the CornerExponent is adjusted within the range ~2-5.
+        private float effectiveCornerRadius => CornerRadius * 0.8f * CornerExponent / 2 + 0.2f * CornerRadius;
+
         private float borderThickness;
 
         /// <summary>
···
                 Vector2 offset = ToParentSpace(Vector2.Zero);
                 Vector2 u = ToParentSpace(new Vector2(cRadius, 0)) - offset;
                 Vector2 v = ToParentSpace(new Vector2(0, cRadius)) - offset;
-                Vector2 inflation = new Vector2((float)Math.Sqrt(u.X * u.X + v.X * v.X), (float)Math.Sqrt(u.Y * u.Y + v.Y * v.Y));
+                Vector2 inflation = new Vector2(
+                    (float)Math.Sqrt(u.X * u.X + v.X * v.X),
+                    (float)Math.Sqrt(u.Y * u.Y + v.Y * v.Y)
+                );
 
                 RectangleF result = ToParentSpace(drawRect).AABBFloat.Inflate(inflation);
                 // The above algorithm will return incorrect results if the rounded corners are not fully visible.

osu.Framework/Graphics/Containers/CompositeDrawable_DrawNode.cs

···
                         MaskingRect = Source.DrawRectangle,
                         ConservativeScreenSpaceQuad = Quad.FromRectangle(shrunkDrawRectangle) * DrawInfo.Matrix,
                         ToMaskingSpace = DrawInfo.MatrixInverse,
-                        CornerRadius = Source.CornerRadius,
+                        CornerRadius = Source.effectiveCornerRadius,
+                        CornerExponent = Source.CornerExponent,
                         BorderThickness = Source.BorderThickness,
                         BorderColour = Source.BorderColour,
                         // We are setting the linear blend range to the approximate size of a _pixel_ here.

osu.Framework/Graphics/Containers/Container.cs

···
         }
 
         /// <summary>
+        /// Determines how gentle the curve of the corner straightens. A value of 2 results in
+        /// circular arcs, a value of 2.5 (default) results in something closer to apple's "continuous curve".
+        /// Recommended range: 2--5. Values outside of that range may result in unpredictable behavior.
+        /// Only has an effect when <see cref="Masking"/> is true and <see cref="CornerRadius"/> is non-zero.
+        /// </summary>
+        public new float CornerExponent
+        {
+            get => base.CornerExponent;
+            set => base.CornerExponent = value;
+        }
+
+        /// <summary>
         /// Determines how thick of a border to draw around the inside of the masked region.
         /// Only has an effect when <see cref="Masking"/> is true.
         /// The border only is drawn on top of children using a sprite shader.

osu.Framework/Graphics/OpenGL/GLWrapper.cs

···
                 ToMaskingSpace = Matrix3.Identity,
                 BlendRange = 1,
                 AlphaExponent = 1,
+                CornerExponent = 2.5f,
             }, true);
 
             PushDepthInfo(DepthInfo.Default);
···
                 maskingInfo.MaskingRect.Bottom));
 
             GlobalPropertyManager.Set(GlobalProperty.ToMaskingSpace, maskingInfo.ToMaskingSpace);
+
             GlobalPropertyManager.Set(GlobalProperty.CornerRadius, maskingInfo.CornerRadius);
+            GlobalPropertyManager.Set(GlobalProperty.CornerExponent, maskingInfo.CornerExponent);
 
             GlobalPropertyManager.Set(GlobalProperty.BorderThickness, maskingInfo.BorderThickness / maskingInfo.BlendRange);
 
···
         public Matrix3 ToMaskingSpace;
 
         public float CornerRadius;
+        public float CornerExponent;
 
         public float BorderThickness;
         public SRGBColour BorderColour;
···
             MaskingRect == other.MaskingRect &&
             ToMaskingSpace == other.ToMaskingSpace &&
             CornerRadius == other.CornerRadius &&
+            CornerExponent == other.CornerExponent &&
             BorderThickness == other.BorderThickness &&
             BorderColour.Equals(other.BorderColour) &&
             BlendRange == other.BlendRange &&

osu.Framework/Graphics/Primitives/RectangleF.cs

···
             return dist.LengthSquared;
         }
 
+        internal float DistanceExponentiated(Vector2 localSpacePos, float exponent)
+        {
+            Vector2 dist = new Vector2(
+                Math.Max(0.0f, Math.Max(localSpacePos.X - Right, Left - localSpacePos.X)),
+                Math.Max(0.0f, Math.Max(localSpacePos.Y - Bottom, Top - localSpacePos.Y))
+            );
+
+            return (float)Math.Pow(dist.X, exponent) + (float)Math.Pow(dist.Y, exponent);
+        }
+
         // This could be optimized further in the future, but made for a simple implementation right now.
         public RectangleI AABB => ((Quad)this).AABB;
 

osu.Framework/Graphics/Shaders/GlobalProperty.cs

···
         MaskingRect,
         ToMaskingSpace,
         CornerRadius,
+        CornerExponent,
         BorderThickness,
         BorderColour,
         MaskingBlendRange,

osu.Framework/Graphics/Shaders/GlobalPropertyManager.cs

···
             global_properties[(int)GlobalProperty.MaskingRect] = new UniformMapping<Vector4>("g_MaskingRect");
             global_properties[(int)GlobalProperty.ToMaskingSpace] = new UniformMapping<Matrix3>("g_ToMaskingSpace");
             global_properties[(int)GlobalProperty.CornerRadius] = new UniformMapping<float>("g_CornerRadius");
+            global_properties[(int)GlobalProperty.CornerExponent] = new UniformMapping<float>("g_CornerExponent");
             global_properties[(int)GlobalProperty.BorderThickness] = new UniformMapping<float>("g_BorderThickness");
             global_properties[(int)GlobalProperty.BorderColour] = new UniformMapping<Vector4>("g_BorderColour");
             global_properties[(int)GlobalProperty.MaskingBlendRange] = new UniformMapping<float>("g_MaskingBlendRange");

osu.Framework/Resources/Shaders/sh_TextureRounded.fs

···
 
 uniform lowp sampler2D m_Sampler;
 uniform highp float g_CornerRadius;
+uniform highp float g_CornerExponent;
 uniform highp vec4 g_MaskingRect;
 uniform highp float g_BorderThickness;
 uniform lowp vec4 g_BorderColour;
···
 		return maxDist;
 	// Outside of the shrunk rectangle
 	else
-		return length(max(vec2(0.0), distanceFromShrunkRect));
+	{
+		distanceFromShrunkRect = max(vec2(0.0), distanceFromShrunkRect);
+		return pow(pow(distanceFromShrunkRect.x, g_CornerExponent) + pow(distanceFromShrunkRect.y, g_CornerExponent), 1.0 / g_CornerExponent);
+	}
 }
 
 highp float distanceFromDrawingRect()