Implement FastCircle component

osu.Framework.Tests/Visual/Drawables/TestSceneFastCircle.cs

@@ -0,0 +1,146 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Framework.Testing;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Framework.Tests.Visual.Drawables
+{
+    public partial class TestSceneFastCircle : ManualInputManagerTestScene
+    {
+        private TestCircle fastCircle = null!;
+        private Circle circle = null!;
+        private CircularContainer fastCircleMask = null!;
+        private CircularContainer circleMask = null!;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Child = new GridContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                RowDimensions = new[]
+                {
+                    new Dimension(GridSizeMode.Absolute, 100),
+                    new Dimension(),
+                },
+                ColumnDimensions = new[]
+                {
+                    new Dimension(GridSizeMode.Relative, 0.5f),
+                    new Dimension()
+                },
+                Content = new[]
+                {
+                    new Drawable[]
+                    {
+                        new SpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Text = "FastCircle"
+                        },
+                        new SpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Text = "Circle"
+                        }
+                    },
+                    new Drawable[]
+                    {
+                        fastCircleMask = new CircularContainer
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.TopRight,
+                            Size = new Vector2(200),
+                            Child = fastCircle = new TestCircle
+                            {
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.Centre,
+                                Size = new Vector2(200),
+                                Clicked = onClick
+                            }
+                        },
+                        circleMask = new CircularContainer
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.TopRight,
+                            Size = new Vector2(200),
+                            Child = circle = new Circle
+                            {
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.Centre,
+                                Size = new Vector2(200)
+                            }
+                        },
+                    }
+                }
+            };
+        });
+
+        [Test]
+        public void TestInput()
+        {
+            testInput(new Vector2(200, 100));
+            testInput(new Vector2(100, 200));
+            testInput(new Vector2(200, 200));
+        }
+
+        [Test]
+        public void TestSmoothness()
+        {
+            AddStep("Change smoothness to 0", () => fastCircle.EdgeSmoothness = circle.MaskingSmoothness = 0);
+            AddStep("Change smoothness to 1", () => fastCircle.EdgeSmoothness = circle.MaskingSmoothness = 1);
+            AddStep("Change smoothness to 5", () => fastCircle.EdgeSmoothness = circle.MaskingSmoothness = 5);
+        }
+
+        [Test]
+        public void TestNestedMasking()
+        {
+            AddToggleStep("Toggle parent masking", m => fastCircleMask.Masking = circleMask.Masking = m);
+        }
+
+        private void testInput(Vector2 size)
+        {
+            AddStep($"Resize to {size}", () =>
+            {
+                fastCircle.Size = circle.Size = size;
+            });
+            AddStep("Click outside the corner", () => clickNearCorner(-Vector2.One));
+            AddAssert("input not received", () => clicked == false);
+            AddStep("Click inside the corner", () => clickNearCorner(Vector2.One));
+            AddAssert("input received", () => clicked);
+        }
+
+        private void clickNearCorner(Vector2 offset)
+        {
+            clicked = false;
+            InputManager.MoveMouseTo(fastCircle.ToScreenSpace(new Vector2(fastCircle.Radius * (1f - MathF.Sqrt(0.5f))) + offset));
+            InputManager.Click(MouseButton.Left);
+        }
+
+        private bool clicked;
+
+        private void onClick() => clicked = true;
+
+        private partial class TestCircle : FastCircle
+        {
+            public Action? Clicked;
+
+            protected override bool OnClick(ClickEvent e)
+            {
+                base.OnClick(e);
+                Clicked?.Invoke();
+                return true;
+            }
+        }
+    }
+}

osu.Framework.Tests/Visual/Performance/TestSceneFastCirclePerformance.cs

@@ -0,0 +1,13 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+
+namespace osu.Framework.Tests.Visual.Performance
+{
+    public sealed partial class TestSceneFastCirclePerformance : RepeatedDrawablePerformanceTestScene
+    {
+        protected override Drawable CreateDrawable() => new FastCircle();
+    }
+}

osu.Framework/Graphics/Shapes/FastCircle.cs

@@ -0,0 +1,126 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. 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.Primitives;
+using osu.Framework.Graphics.Rendering;
+using osu.Framework.Graphics.Rendering.Vertices;
+using osu.Framework.Graphics.Shaders;
+using osuTK;
+
+namespace osu.Framework.Graphics.Shapes
+{
+    public partial class FastCircle : Drawable
+    {
+        private float edgeSmoothness = 1f;
+
+        public float EdgeSmoothness
+        {
+            get => edgeSmoothness;
+            set
+            {
+                if (edgeSmoothness == value)
+                    return;
+
+                edgeSmoothness = value;
+
+                if (IsLoaded)
+                    Invalidate(Invalidation.DrawNode);
+            }
+        }
+
+        private IShader shader = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(ShaderManager shaders)
+        {
+            shader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, "FastCircle");
+        }
+
+        public float Radius => MathF.Min(DrawSize.X, DrawSize.Y) * 0.5f;
+
+        public override bool Contains(Vector2 screenSpacePos)
+        {
+            if (!base.Contains(screenSpacePos))
+                return false;
+
+            float cRadius = Radius;
+            return DrawRectangle.Shrink(cRadius).DistanceExponentiated(ToLocalSpace(screenSpacePos), 2f) <= cRadius * cRadius;
+        }
+
+        protected override DrawNode CreateDrawNode() => new FastCircleDrawNode(this);
+
+        private class FastCircleDrawNode : DrawNode
+        {
+            protected new FastCircle Source => (FastCircle)base.Source;
+
+            public FastCircleDrawNode(FastCircle source)
+                : base(source)
+            {
+            }
+
+            private Quad screenSpaceDrawQuad;
+            private Vector4 drawRectangle;
+            private Vector2 edgeSmoothness;
+            private IShader shader = null!;
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                screenSpaceDrawQuad = Source.ScreenSpaceDrawQuad;
+                drawRectangle = new Vector4(0, 0, screenSpaceDrawQuad.Width, screenSpaceDrawQuad.Height);
+                shader = Source.shader;
+                edgeSmoothness = new Vector2(Source.edgeSmoothness);
+            }
+
+            protected override void Draw(IRenderer renderer)
+            {
+                base.Draw(renderer);
+
+                if (!renderer.BindTexture(renderer.WhitePixel))
+                    return;
+
+                shader.Bind();
+
+                var vertexAction = renderer.DefaultQuadBatch.AddAction;
+
+                vertexAction(new TexturedVertex2D(renderer)
+                {
+                    Position = screenSpaceDrawQuad.BottomLeft,
+                    TexturePosition = new Vector2(0, screenSpaceDrawQuad.Height),
+                    TextureRect = drawRectangle,
+                    BlendRange = edgeSmoothness,
+                    Colour = DrawColourInfo.Colour.BottomLeft.SRGB,
+                });
+                vertexAction(new TexturedVertex2D(renderer)
+                {
+                    Position = screenSpaceDrawQuad.BottomRight,
+                    TexturePosition = new Vector2(screenSpaceDrawQuad.Width, screenSpaceDrawQuad.Height),
+                    TextureRect = drawRectangle,
+                    BlendRange = edgeSmoothness,
+                    Colour = DrawColourInfo.Colour.BottomRight.SRGB,
+                });
+                vertexAction(new TexturedVertex2D(renderer)
+                {
+                    Position = screenSpaceDrawQuad.TopRight,
+                    TexturePosition = new Vector2(screenSpaceDrawQuad.Width, 0),
+                    TextureRect = drawRectangle,
+                    BlendRange = edgeSmoothness,
+                    Colour = DrawColourInfo.Colour.TopRight.SRGB,
+                });
+                vertexAction(new TexturedVertex2D(renderer)
+                {
+                    Position = screenSpaceDrawQuad.TopLeft,
+                    TexturePosition = new Vector2(0, 0),
+                    TextureRect = drawRectangle,
+                    BlendRange = edgeSmoothness,
+                    Colour = DrawColourInfo.Colour.TopLeft.SRGB,
+                });
+
+                shader.Unbind();
+            }
+        }
+    }
+}

osu.Framework/Resources/Shaders/sh_FastCircle.fs

@@ -0,0 +1,26 @@
+#ifndef FAST_CIRCLE_FS
+#define FAST_CIRCLE_FS
+
+#undef HIGH_PRECISION_VERTEX
+#define HIGH_PRECISION_VERTEX
+
+#include "sh_Utils.h"
+#include "sh_Masking.h"
+
+layout(location = 2) in highp vec2 v_TexCoord;
+
+layout(location = 0) out vec4 o_Colour;
+
+void main(void)
+{
+    highp vec2 pixelPos = v_TexRect.zw * 0.5 - abs(v_TexCoord - v_TexRect.zw * 0.5);
+    highp float radius = min(v_TexRect.z, v_TexRect.w) * 0.5;
+
+    highp float dst = max(pixelPos.x, pixelPos.y) > radius ? radius - min(pixelPos.x, pixelPos.y) : distance(pixelPos, vec2(radius));
+
+    highp float alpha = v_BlendRange.x == 0.0 ? float(dst < radius) : (clamp(radius - dst, 0.0, v_BlendRange.x) / v_BlendRange.x);
+
+    o_Colour = getRoundedColor(vec4(vec3(1.0), alpha), vec2(0.0));
+}
+
+#endif