Merge remote-tracking branch 'ppy/master' into rename_test_case

osu.Framework.Tests/Clocks/InterpolatingClockTest.cs

···
                 Assert.GreaterOrEqual(interpolating.CurrentTime, source.CurrentTime, "Interpolating should not jump before source time.");
 
                 Thread.Sleep((int)(interpolating.AllowableErrorMilliseconds / 2));
+                lastValue = interpolating.CurrentTime;
             }
+
+            int interpolatingCount = 0;
 
             // test with test clock elapsing
             lastValue = interpolating.CurrentTime;
···
 
                 Assert.GreaterOrEqual(interpolating.CurrentTime, lastValue, "Interpolating should not jump against rate.");
                 Assert.LessOrEqual(Math.Abs(interpolating.CurrentTime - source.CurrentTime), interpolating.AllowableErrorMilliseconds, "Interpolating should be within allowance.");
+
+                if (interpolating.CurrentTime != source.CurrentTime)
+                    interpolatingCount++;
 
                 Thread.Sleep((int)(interpolating.AllowableErrorMilliseconds / 2));
+                lastValue = interpolating.CurrentTime;
             }
+
+            Assert.Greater(interpolatingCount, 10);
+        }
+
+        [Test]
+        public void NeverInterpolatesBackwardsOnInterpolationFail()
+        {
+            double lastValue = interpolating.CurrentTime;
+
+            source.Start();
+            source.Rate = 10; // use a higher rate to ensure we may seek backwards.
+
+            int sleepTime = (int)(interpolating.AllowableErrorMilliseconds / 2);
+
+            int interpolatingCount = 0;
+
+            for (int i = 0; i < 200; i++)
+            {
+                if (i < 100) // stop the elapsing at some point in time. should still work as source's ElapsedTime is zero.
+                    source.CurrentTime += sleepTime * source.Rate;
+
+                interpolating.ProcessFrame();
+
+                if (interpolating.CurrentTime != source.CurrentTime)
+                    interpolatingCount++;
+
+                Assert.GreaterOrEqual(interpolating.CurrentTime, lastValue, "Interpolating should not jump against rate.");
+                Assert.LessOrEqual(Math.Abs(interpolating.CurrentTime - source.CurrentTime), interpolating.AllowableErrorMilliseconds, "Interpolating should be within allowance.");
+
+                Thread.Sleep(sleepTime);
+                lastValue = interpolating.CurrentTime;
+            }
+
+            Assert.Greater(interpolatingCount, 10);
         }
 
         [Test]

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

···
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(BufferedContainer),
-            typeof(BufferedContainerDrawNode),
         };
 
         public TestSceneCachedBufferedContainer()

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

···
 using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;

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

···
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;

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

···
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Transforms;

osu.Framework.Tests/Visual/Testing/TestSceneTest.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Development;
 using osu.Framework.Testing;
 
 namespace osu.Framework.Tests.Visual.Testing
···
                 // [SetUp] gets run via TestConstructor() when we are running under nUnit.
                 // note that in TestBrowser's case, this does not invoke SetUp methods, so we skip this increment.
                 // schedule is required to ensure that IsNUnitRunning is initialised.
-                if (IsNUnitRunning)
+                if (DebugUtils.IsNUnitRunning)
                     testRunCount++;
             });
 
···
         {
             AddStep("increment run count", () => testRunCount++);
             AddAssert("correct setup run count", () => testRunCount == setupRun);
-            AddAssert("correct setup steps run count", () => (IsNUnitRunning ? testRunCount : 2) == setupStepsRun);
+            AddAssert("correct setup steps run count", () => (DebugUtils.IsNUnitRunning ? testRunCount : 2) == setupStepsRun);
         }
 
         [Test]
···
         {
             AddStep("increment run count", () => testRunCount++);
             AddAssert("correct setup run count", () => testRunCount == setupRun);
-            AddAssert("correct setup steps run count", () => (IsNUnitRunning ? testRunCount : 2) == setupStepsRun);
+            AddAssert("correct setup steps run count", () => (DebugUtils.IsNUnitRunning ? testRunCount : 2) == setupStepsRun);
         }
 
         protected override ITestSceneTestRunner CreateRunner() => new TestRunner();

osu.Framework/Development/DebugUtils.cs

···
 
 using System;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Reflection;
+using NUnit.Framework;
 
 namespace osu.Framework.Development
 {
     public static class DebugUtils
     {
+        internal static Assembly HostAssembly { get; set; }
+
+        public static bool IsNUnitRunning => is_nunit_running.Value;
+
+        private static readonly Lazy<bool> is_nunit_running = new Lazy<bool>(() =>
+            {
+                var entry = Assembly.GetEntryAssembly();
+
+                // when running under nunit + netcore, entry assembly becomes nunit itself (testhost, Version=15.0.0.0), which isn't what we want.
+                return entry == null || entry.Location.Contains("testhost");
+            }
+        );
+
         public static bool IsDebugBuild => is_debug_build.Value;
 
         private static readonly Lazy<bool> is_debug_build = new Lazy<bool>(() =>
-            isDebugAssembly(typeof(DebugUtils).Assembly) || isDebugAssembly(Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly())
+            isDebugAssembly(typeof(DebugUtils).Assembly) || isDebugAssembly(GetEntryAssembly())
         );
 
         // https://stackoverflow.com/a/2186634
         private static bool isDebugAssembly(Assembly assembly) => assembly.GetCustomAttributes(false).OfType<DebuggableAttribute>().Any(da => da.IsJITTrackingEnabled);
+
+        /// <summary>
+        /// Get the entry assembly, even when running under nUnit.
+        /// </summary>
+        /// <returns>The entry assembly (usually obtained via <see cref="Assembly.GetEntryAssembly()"/>.</returns>
+        public static Assembly GetEntryAssembly() =>
+            HostAssembly ?? Assembly.GetEntryAssembly();
+
+        /// <summary>
+        /// Get the entry path, even when running under nUnit.
+        /// </summary>
+        /// <returns>The entry assembly (usually obtained via the entry assembly's <see cref="Assembly.Location"/>.</returns>
+        public static string GetEntryPath() =>
+            IsNUnitRunning ? TestContext.CurrentContext.TestDirectory : Path.GetDirectoryName(GetEntryAssembly().Location);
     }
 }

osu.Framework/Graphics/Audio/WaveformGraph.cs

···
             cancelSource = null;
         }
 
-        protected override DrawNode CreateDrawNode() => new WaveformDrawNode();
-
-        protected override void ApplyDrawNode(DrawNode node)
-        {
-            var n = (WaveformDrawNode)node;
-
-            n.Shader = shader;
-            n.Texture = texture;
-            n.DrawSize = DrawSize;
-            n.Points = ResampledWaveform?.GetPoints();
-            n.Channels = ResampledWaveform?.GetChannels() ?? 0;
-            n.LowColour = lowColour ?? DrawColourInfo.Colour;
-            n.MidColour = midColour ?? DrawColourInfo.Colour;
-            n.HighColour = highColour ?? DrawColourInfo.Colour;
-
-            base.ApplyDrawNode(node);
-        }
+        protected override DrawNode CreateDrawNode() => new WaveformDrawNode(this);
 
         protected override void Dispose(bool isDisposing)
         {
···
 
         private class WaveformDrawNode : DrawNode
         {
-            public IShader Shader;
-            public Texture Texture;
+            private IShader shader;
+            private Texture texture;
 
-            public Vector2 DrawSize;
-            public int Channels;
+            private IReadOnlyList<WaveformPoint> points;
 
-            public Color4 LowColour;
-            public Color4 MidColour;
-            public Color4 HighColour;
+            private Vector2 drawSize;
+            private int channels;
 
-            private IReadOnlyList<WaveformPoint> points;
+            private Color4 lowColour;
+            private Color4 midColour;
+            private Color4 highColour;
 
             private double highMax;
             private double midMax;
             private double lowMax;
 
-            public IReadOnlyList<WaveformPoint> Points
+            protected new WaveformGraph Source => (WaveformGraph)base.Source;
+
+            public WaveformDrawNode(WaveformGraph source)
+                : base(source)
             {
-                get => points;
-                set
-                {
-                    points = value;
+            }
 
-                    if (points?.Any() == true)
-                    {
-                        highMax = points.Max(p => p.HighIntensity);
-                        midMax = points.Max(p => p.MidIntensity);
-                        lowMax = points.Max(p => p.LowIntensity);
-                    }
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                shader = Source.shader;
+                texture = Source.texture;
+                drawSize = Source.DrawSize;
+                points = Source.ResampledWaveform?.GetPoints();
+                channels = Source.ResampledWaveform?.GetChannels() ?? 0;
+                lowColour = Source.lowColour ?? DrawColourInfo.Colour;
+                midColour = Source.midColour ?? DrawColourInfo.Colour;
+                highColour = Source.highColour ?? DrawColourInfo.Colour;
+
+                if (points?.Any() == true)
+                {
+                    highMax = points.Max(p => p.HighIntensity);
+                    midMax = points.Max(p => p.MidIntensity);
+                    lowMax = points.Max(p => p.LowIntensity);
                 }
             }
 
···
             {
                 base.Draw(vertexAction);
 
-                if (Texture?.Available != true || points == null || points.Count == 0)
+                if (texture?.Available != true || points == null || points.Count == 0)
                     return;
 
-                Shader.Bind();
-                Texture.TextureGL.Bind();
+                shader.Bind();
+                texture.TextureGL.Bind();
 
                 Vector2 localInflationAmount = new Vector2(0, 1) * DrawInfo.MatrixInverse.ExtractScale().Xy;
 
···
                 // Since the points are generated in the local coordinate space, we need to convert the screen space masking quad coordinates into the local coordinate space
                 RectangleF localMaskingRectangle = (Quad.FromRectangle(GLWrapper.CurrentMaskingInfo.ScreenSpaceAABB) * DrawInfo.MatrixInverse).AABBFloat;
 
-                float separation = DrawSize.X / (points.Count - 1);
+                float separation = drawSize.X / (points.Count - 1);
 
                 for (int i = 0; i < points.Count - 1; i++)
                 {
···
                     Color4 colour = DrawColourInfo.Colour;
 
                     // colouring is applied in the order of interest to a viewer.
-                    colour = Interpolation.ValueAt(points[i].MidIntensity / midMax, colour, MidColour, 0, 1);
+                    colour = Interpolation.ValueAt(points[i].MidIntensity / midMax, colour, midColour, 0, 1);
                     // high end (cymbal) can help find beat, so give it priority over mids.
-                    colour = Interpolation.ValueAt(points[i].HighIntensity / highMax, colour, HighColour, 0, 1);
+                    colour = Interpolation.ValueAt(points[i].HighIntensity / highMax, colour, highColour, 0, 1);
                     // low end (bass drum) is generally the best visual aid for beat matching, so give it priority over high/mid.
-                    colour = Interpolation.ValueAt(points[i].LowIntensity / lowMax, colour, LowColour, 0, 1);
+                    colour = Interpolation.ValueAt(points[i].LowIntensity / lowMax, colour, lowColour, 0, 1);
 
                     Quad quadToDraw;
 
-                    switch (Channels)
+                    switch (channels)
                     {
                         default:
                         case 2:
                         {
-                            float height = DrawSize.Y / 2;
+                            float height = drawSize.Y / 2;
                             quadToDraw = new Quad(
                                 new Vector2(leftX, height - points[i].Amplitude[0] * height),
                                 new Vector2(rightX, height - points[i + 1].Amplitude[0] * height),
···
                         case 1:
                         {
                             quadToDraw = new Quad(
-                                new Vector2(leftX, DrawSize.Y - points[i].Amplitude[0] * DrawSize.Y),
-                                new Vector2(rightX, DrawSize.Y - points[i + 1].Amplitude[0] * DrawSize.Y),
-                                new Vector2(leftX, DrawSize.Y),
-                                new Vector2(rightX, DrawSize.Y)
+                                new Vector2(leftX, drawSize.Y - points[i].Amplitude[0] * drawSize.Y),
+                                new Vector2(rightX, drawSize.Y - points[i + 1].Amplitude[0] * drawSize.Y),
+                                new Vector2(leftX, drawSize.Y),
+                                new Vector2(rightX, drawSize.Y)
                             );
                             break;
                         }
                     }
 
                     quadToDraw *= DrawInfo.Matrix;
-                    Texture.DrawQuad(quadToDraw, colour, null, vertexBatch.AddAction, Vector2.Divide(localInflationAmount, quadToDraw.Size));
+                    texture.DrawQuad(quadToDraw, colour, null, vertexBatch.AddAction, Vector2.Divide(localInflationAmount, quadToDraw.Size));
                 }
 
-                Shader.Unbind();
+                shader.Unbind();
             }
 
             protected override void Dispose(bool isDisposing)

osu.Framework/Graphics/Containers/BufferedContainer.cs

···
     /// appearance of the container at the cost of performance. Such effects include
     /// uniform fading of children, blur, and other post-processing effects.
     /// </summary>
-    public class BufferedContainer<T> : Container<T>, IBufferedContainer
+    public partial class BufferedContainer<T> : Container<T>, IBufferedContainer
         where T : Drawable
     {
         private bool drawOriginal;
···
             blurShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.BLUR);
         }
 
-        private bool addChildDrawNodes;
-        internal override bool AddChildDrawNodes => addChildDrawNodes;
-
         private readonly BufferedContainerDrawNodeSharedData sharedData = new BufferedContainerDrawNodeSharedData();
 
-        protected override DrawNode CreateDrawNode() => new BufferedContainerDrawNode();
-
-        protected override void ApplyDrawNode(DrawNode node)
-        {
-            BufferedContainerDrawNode n = (BufferedContainerDrawNode)node;
-
-            n.ScreenSpaceDrawRectangle = ScreenSpaceDrawQuad.AABBFloat;
-            n.FilteringMode = pixelSnapping ? All.Nearest : All.Linear;
-
-            n.UpdateVersion = updateVersion;
-            n.BackgroundColour = backgroundColour;
-
-            BlendingParameters localEffectBlending = EffectBlending;
-            if (localEffectBlending.Mode == BlendingMode.Inherit)
-                localEffectBlending.Mode = Blending.Mode;
-
-            if (localEffectBlending.RGBEquation == BlendingEquation.Inherit)
-                localEffectBlending.RGBEquation = Blending.RGBEquation;
-
-            if (localEffectBlending.AlphaEquation == BlendingEquation.Inherit)
-                localEffectBlending.AlphaEquation = Blending.AlphaEquation;
-
-            n.EffectColour = effectColour;
-            n.EffectBlending = localEffectBlending;
-            n.EffectPlacement = effectPlacement;
-
-            n.DrawOriginal = drawOriginal;
-            n.BlurSigma = blurSigma;
-            n.BlurRadius = new Vector2I(Blur.KernelSize(BlurSigma.X), Blur.KernelSize(BlurSigma.Y));
-            n.BlurRotation = blurRotation;
-
-            n.Formats.Clear();
-            n.Formats.AddRange(attachedFormats);
-
-            n.BlurShader = blurShader;
-
-            n.SharedData = sharedData;
-
-            base.ApplyDrawNode(node);
-
-            // Our own draw node should contain our correct color, hence we have
-            // to undo our overridden DrawInfo getter here.
-            n.DrawColourInfo = new DrawColourInfo(base.DrawColourInfo.Colour, n.DrawColourInfo.Blending);
-
-            // Only need to generate child draw nodes if the framebuffers will get redrawn this time around
-            addChildDrawNodes = n.RequiresRedraw;
-        }
-
-        internal override DrawNode GenerateDrawNodeSubtree(ulong frame, int treeIndex, bool forceNewDrawNode)
-        {
-            var result = base.GenerateDrawNodeSubtree(frame, treeIndex, forceNewDrawNode);
-
-            // The framebuffers may be redrawn this time around, but will be cached the next time around
-            addChildDrawNodes = false;
-
-            return result;
-        }
+        protected override DrawNode CreateDrawNode() => new BufferedContainerDrawNode(this, sharedData);
 
         private readonly List<RenderbufferInternalFormat> attachedFormats = new List<RenderbufferInternalFormat>();
 
···
 
             childrenUpdateVersion = updateVersion;
         }
+
+        private DrawColourInfo baseDrawColourInfo => base.DrawColourInfo;
 
         public override DrawColourInfo DrawColourInfo
         {

osu.Framework/Graphics/Containers/BufferedContainerDrawNode.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 System.Collections.Generic;
-using osu.Framework.Graphics.OpenGL;
-using osu.Framework.Graphics.OpenGL.Buffers;
-using osuTK;
-using osuTK.Graphics.ES30;
-using osuTK.Graphics;
-using osu.Framework.Graphics.Primitives;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics.Shaders;
-using System;
-using osu.Framework.Graphics.Colour;
-using osu.Framework.Graphics.OpenGL.Vertices;
-using System.Diagnostics;
-
-namespace osu.Framework.Graphics.Containers
-{
-    public class BufferedContainerDrawNodeSharedData : IDisposable
-    {
-        /// <summary>
-        /// The <see cref="FrameBuffer"/>s to render to.
-        /// These are used in a ping-pong manner to render effects <see cref="BufferedContainerDrawNode"/>.
-        /// </summary>
-        public readonly FrameBuffer[] FrameBuffers = new FrameBuffer[3];
-
-        /// <summary>
-        /// The version of drawn contents currently present in <see cref="FrameBuffers"/>.
-        /// This should only be modified by <see cref="BufferedContainerDrawNode"/>.
-        /// </summary>
-        public long DrawVersion = -1;
-
-        public BufferedContainerDrawNodeSharedData()
-        {
-            for (int i = 0; i < FrameBuffers.Length; i++)
-                FrameBuffers[i] = new FrameBuffer();
-        }
-
-        ~BufferedContainerDrawNodeSharedData()
-        {
-            Dispose(false);
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        protected virtual void Dispose(bool isDisposing)
-        {
-            for (int i = 0; i < FrameBuffers.Length; i++)
-                FrameBuffers[i].Dispose();
-        }
-    }
-
-    public class BufferedContainerDrawNode : CompositeDrawNode
-    {
-        public bool DrawOriginal;
-        public Color4 BackgroundColour;
-        public ColourInfo EffectColour;
-        public BlendingParameters EffectBlending;
-        public EffectPlacement EffectPlacement;
-
-        public Vector2 BlurSigma;
-        public Vector2I BlurRadius;
-        public float BlurRotation;
-
-        public long UpdateVersion;
-
-        public RectangleF ScreenSpaceDrawRectangle;
-        public All FilteringMode;
-
-        /// <summary>
-        /// The <see cref="RenderbufferInternalFormat"/>s to use when drawing children.
-        /// </summary>
-        public readonly List<RenderbufferInternalFormat> Formats = new List<RenderbufferInternalFormat>();
-
-        /// <summary>
-        /// The <see cref="IShader"/> to use when rendering blur effects.
-        /// </summary>
-        public IShader BlurShader;
-
-        public BufferedContainerDrawNodeSharedData SharedData;
-
-        /// <summary>
-        /// Whether this <see cref="BufferedContainerDrawNode"/> should have its children re-drawn.
-        /// </summary>
-        public bool RequiresRedraw => UpdateVersion > SharedData.DrawVersion;
-
-        private ValueInvokeOnDisposal establishFrameBufferViewport(Vector2 roundedSize)
-        {
-            // Disable masking for generating the frame buffer since masking will be re-applied
-            // when actually drawing later on anyways. This allows more information to be captured
-            // in the frame buffer and helps with cached buffers being re-used.
-            RectangleI screenSpaceMaskingRect = new RectangleI((int)Math.Floor(ScreenSpaceDrawRectangle.X), (int)Math.Floor(ScreenSpaceDrawRectangle.Y), (int)roundedSize.X + 1, (int)roundedSize.Y + 1);
-
-            GLWrapper.PushMaskingInfo(new MaskingInfo
-            {
-                ScreenSpaceAABB = screenSpaceMaskingRect,
-                MaskingRect = ScreenSpaceDrawRectangle,
-                ToMaskingSpace = Matrix3.Identity,
-                BlendRange = 1,
-                AlphaExponent = 1,
-            }, true);
-
-            // Match viewport to FrameBuffer such that we don't draw unnecessary pixels.
-            GLWrapper.PushViewport(new RectangleI(0, 0, (int)roundedSize.X, (int)roundedSize.Y));
-
-            return new ValueInvokeOnDisposal(returnViewport);
-        }
-
-        private void returnViewport()
-        {
-            GLWrapper.PopViewport();
-            GLWrapper.PopMaskingInfo();
-        }
-
-        private ValueInvokeOnDisposal bindFrameBuffer(FrameBuffer frameBuffer, Vector2 requestedSize)
-        {
-            if (!frameBuffer.IsInitialized)
-                frameBuffer.Initialize(true, FilteringMode);
-
-            // These additional render buffers are only required if e.g. depth
-            // or stencil information needs to also be stored somewhere.
-            foreach (var f in Formats)
-                frameBuffer.Attach(f);
-
-            // This setter will also take care of allocating a texture of appropriate size within the framebuffer.
-            frameBuffer.Size = requestedSize;
-
-            frameBuffer.Bind();
-
-            return new ValueInvokeOnDisposal(frameBuffer.Unbind);
-        }
-
-        private void drawFrameBufferToBackBuffer(FrameBuffer frameBuffer, RectangleF drawRectangle, ColourInfo colourInfo)
-        {
-            // The strange Y coordinate and Height are a result of OpenGL coordinate systems having Y grow upwards and not downwards.
-            RectangleF textureRect = new RectangleF(0, frameBuffer.Texture.Height, frameBuffer.Texture.Width, -frameBuffer.Texture.Height);
-            if (frameBuffer.Texture.Bind())
-                // Color was already applied by base.Draw(); no need to re-apply. Thus we use White here.
-                frameBuffer.Texture.DrawQuad(drawRectangle, textureRect, colourInfo);
-        }
-
-        private void drawChildren(Action<TexturedVertex2D> vertexAction, Vector2 frameBufferSize)
-        {
-            // Fill the frame buffer with drawn children
-            using (bindFrameBuffer(currentFrameBuffer, frameBufferSize))
-            {
-                // We need to draw children as if they were zero-based to the top-left of the texture.
-                // We can do this by adding a translation component to our (orthogonal) projection matrix.
-                GLWrapper.PushOrtho(ScreenSpaceDrawRectangle);
-
-                GLWrapper.Clear(new ClearInfo(BackgroundColour));
-                base.Draw(vertexAction);
-
-                GLWrapper.PopOrtho();
-            }
-        }
-
-        private void drawBlurredFrameBuffer(int kernelRadius, float sigma, float blurRotation)
-        {
-            FrameBuffer source = currentFrameBuffer;
-            FrameBuffer target = advanceFrameBuffer();
-
-            GLWrapper.SetBlend(new BlendingInfo(BlendingMode.None));
-
-            using (bindFrameBuffer(target, source.Size))
-            {
-                BlurShader.GetUniform<int>(@"g_Radius").UpdateValue(ref kernelRadius);
-                BlurShader.GetUniform<float>(@"g_Sigma").UpdateValue(ref sigma);
-
-                Vector2 size = source.Size;
-                BlurShader.GetUniform<Vector2>(@"g_TexSize").UpdateValue(ref size);
-
-                float radians = -MathHelper.DegreesToRadians(blurRotation);
-                Vector2 blur = new Vector2((float)Math.Cos(radians), (float)Math.Sin(radians));
-                BlurShader.GetUniform<Vector2>(@"g_BlurDirection").UpdateValue(ref blur);
-
-                BlurShader.Bind();
-                drawFrameBufferToBackBuffer(source, new RectangleF(0, 0, source.Texture.Width, source.Texture.Height), ColourInfo.SingleColour(Color4.White));
-                BlurShader.Unbind();
-            }
-        }
-
-        private int currentFrameBufferIndex;
-        private FrameBuffer currentFrameBuffer => SharedData.FrameBuffers[currentFrameBufferIndex];
-        private FrameBuffer advanceFrameBuffer() => SharedData.FrameBuffers[currentFrameBufferIndex = (currentFrameBufferIndex + 1) % 2];
-
-        /// <summary>
-        /// Makes sure the first frame buffer is always the one we want to draw from.
-        /// This saves us the need to sync the draw indices across draw node trees
-        /// since the SharedData.FrameBuffers array is already shared.
-        /// </summary>
-        private void finalizeFrameBuffer()
-        {
-            if (currentFrameBufferIndex != 0)
-            {
-                Trace.Assert(currentFrameBufferIndex == 1,
-                    $"Only the first two framebuffers should be the last to be written to at the end of {nameof(Draw)}.");
-
-                FrameBuffer temp = SharedData.FrameBuffers[0];
-                SharedData.FrameBuffers[0] = SharedData.FrameBuffers[1];
-                SharedData.FrameBuffers[1] = temp;
-
-                currentFrameBufferIndex = 0;
-            }
-        }
-
-        // Our effects will be drawn into framebuffers 0 and 1. If we want to preserve the originally
-        // drawn children we need to put them in a separate buffer; in this case buffer 2. Otherwise,
-        // we do not want to allocate a third buffer for nothing and hence we start with 0.
-        private int originalIndex => DrawOriginal && (BlurRadius.X > 0 || BlurRadius.Y > 0) ? 2 : 0;
-
-        public override void Draw(Action<TexturedVertex2D> vertexAction)
-        {
-            currentFrameBufferIndex = originalIndex;
-
-            Vector2 frameBufferSize = new Vector2((float)Math.Ceiling(ScreenSpaceDrawRectangle.Width), (float)Math.Ceiling(ScreenSpaceDrawRectangle.Height));
-            if (RequiresRedraw)
-            {
-                SharedData.DrawVersion = UpdateVersion;
-
-                using (establishFrameBufferViewport(frameBufferSize))
-                {
-                    drawChildren(vertexAction, frameBufferSize);
-
-                    // Blur post-processing in case a blur radius is defined.
-                    if (BlurRadius.X > 0 || BlurRadius.Y > 0)
-                    {
-                        GL.Disable(EnableCap.ScissorTest);
-
-                        if (BlurRadius.X > 0) drawBlurredFrameBuffer(BlurRadius.X, BlurSigma.X, BlurRotation);
-                        if (BlurRadius.Y > 0) drawBlurredFrameBuffer(BlurRadius.Y, BlurSigma.Y, BlurRotation + 90);
-
-                        GL.Enable(EnableCap.ScissorTest);
-                    }
-                }
-
-                finalizeFrameBuffer();
-            }
-
-            RectangleF drawRectangle = FilteringMode == All.Nearest
-                ? new RectangleF(ScreenSpaceDrawRectangle.X, ScreenSpaceDrawRectangle.Y, frameBufferSize.X, frameBufferSize.Y)
-                : ScreenSpaceDrawRectangle;
-
-            Shader.Bind();
-
-            if (DrawOriginal && EffectPlacement == EffectPlacement.InFront)
-            {
-                GLWrapper.SetBlend(DrawColourInfo.Blending);
-                drawFrameBufferToBackBuffer(SharedData.FrameBuffers[originalIndex], drawRectangle, DrawColourInfo.Colour);
-            }
-
-            // Blit the final framebuffer to screen.
-            GLWrapper.SetBlend(new BlendingInfo(EffectBlending));
-
-            ColourInfo effectColour = DrawColourInfo.Colour;
-            effectColour.ApplyChild(EffectColour);
-            drawFrameBufferToBackBuffer(SharedData.FrameBuffers[0], drawRectangle, effectColour);
-
-            if (DrawOriginal && EffectPlacement == EffectPlacement.Behind)
-            {
-                GLWrapper.SetBlend(DrawColourInfo.Blending);
-                drawFrameBufferToBackBuffer(SharedData.FrameBuffers[originalIndex], drawRectangle, DrawColourInfo.Colour);
-            }
-
-            Shader.Unbind();
-        }
-    }
-}

osu.Framework/Graphics/Containers/BufferedContainer_DrawNode.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 System.Collections.Generic;
+using osu.Framework.Graphics.OpenGL;
+using osu.Framework.Graphics.OpenGL.Buffers;
+using osuTK;
+using osuTK.Graphics.ES30;
+using osuTK.Graphics;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Shaders;
+using System;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.OpenGL.Vertices;
+using System.Diagnostics;
+using osu.Framework.MathUtils;
+
+namespace osu.Framework.Graphics.Containers
+{
+    public partial class BufferedContainer<T>
+    {
+        private class BufferedContainerDrawNode : CompositeDrawableDrawNode
+        {
+            protected new BufferedContainer<T> Source => (BufferedContainer<T>)base.Source;
+
+            private bool drawOriginal;
+            private Color4 backgroundColour;
+            private ColourInfo effectColour;
+            private BlendingParameters effectBlending;
+            private EffectPlacement effectPlacement;
+
+            private Vector2 blurSigma;
+            private Vector2I blurRadius;
+            private float blurRotation;
+
+            private long updateVersion;
+
+            private RectangleF screenSpaceDrawRectangle;
+            private All filteringMode;
+
+            private readonly List<RenderbufferInternalFormat> formats = new List<RenderbufferInternalFormat>();
+
+            private IShader blurShader;
+
+            private readonly BufferedContainerDrawNodeSharedData sharedData;
+
+            public BufferedContainerDrawNode(BufferedContainer<T> source, BufferedContainerDrawNodeSharedData sharedData)
+                : base(source)
+            {
+                this.sharedData = sharedData;
+            }
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                screenSpaceDrawRectangle = Source.ScreenSpaceDrawQuad.AABBFloat;
+                filteringMode = Source.PixelSnapping ? All.Nearest : All.Linear;
+
+                updateVersion = Source.updateVersion;
+                backgroundColour = Source.BackgroundColour;
+
+                BlendingParameters localEffectBlending = Source.EffectBlending;
+                if (localEffectBlending.Mode == BlendingMode.Inherit)
+                    localEffectBlending.Mode = Source.Blending.Mode;
+
+                if (localEffectBlending.RGBEquation == BlendingEquation.Inherit)
+                    localEffectBlending.RGBEquation = Source.Blending.RGBEquation;
+
+                if (localEffectBlending.AlphaEquation == BlendingEquation.Inherit)
+                    localEffectBlending.AlphaEquation = Source.Blending.AlphaEquation;
+
+                effectColour = Source.EffectColour;
+                effectBlending = localEffectBlending;
+                effectPlacement = Source.EffectPlacement;
+
+                drawOriginal = Source.DrawOriginal;
+                blurSigma = Source.BlurSigma;
+                blurRadius = new Vector2I(Blur.KernelSize(blurSigma.X), Blur.KernelSize(blurSigma.Y));
+                blurRotation = Source.BlurRotation;
+
+                formats.Clear();
+                formats.AddRange(Source.attachedFormats);
+
+                blurShader = Source.blurShader;
+
+                // BufferedContainer overrides DrawColourInfo for children, but needs to be reset to draw ourselves
+                DrawColourInfo = Source.baseDrawColourInfo;
+            }
+
+            public override bool AddChildDrawNodes => RequiresRedraw;
+
+            /// <summary>
+            /// Whether this <see cref="BufferedContainerDrawNode"/> should have its children re-drawn.
+            /// </summary>
+            public bool RequiresRedraw => updateVersion > sharedData.DrawVersion;
+
+            private ValueInvokeOnDisposal establishFrameBufferViewport(Vector2 roundedSize)
+            {
+                // Disable masking for generating the frame buffer since masking will be re-applied
+                // when actually drawing later on anyways. This allows more information to be captured
+                // in the frame buffer and helps with cached buffers being re-used.
+                RectangleI screenSpaceMaskingRect = new RectangleI((int)Math.Floor(screenSpaceDrawRectangle.X), (int)Math.Floor(screenSpaceDrawRectangle.Y), (int)roundedSize.X + 1,
+                    (int)roundedSize.Y + 1);
+
+                GLWrapper.PushMaskingInfo(new MaskingInfo
+                {
+                    ScreenSpaceAABB = screenSpaceMaskingRect,
+                    MaskingRect = screenSpaceDrawRectangle,
+                    ToMaskingSpace = Matrix3.Identity,
+                    BlendRange = 1,
+                    AlphaExponent = 1,
+                }, true);
+
+                // Match viewport to FrameBuffer such that we don't draw unnecessary pixels.
+                GLWrapper.PushViewport(new RectangleI(0, 0, (int)roundedSize.X, (int)roundedSize.Y));
+
+                return new ValueInvokeOnDisposal(returnViewport);
+            }
+
+            private void returnViewport()
+            {
+                GLWrapper.PopViewport();
+                GLWrapper.PopMaskingInfo();
+            }
+
+            private ValueInvokeOnDisposal bindFrameBuffer(FrameBuffer frameBuffer, Vector2 requestedSize)
+            {
+                if (!frameBuffer.IsInitialized)
+                    frameBuffer.Initialize(true, filteringMode);
+
+                // These additional render buffers are only required if e.g. depth
+                // or stencil information needs to also be stored somewhere.
+                foreach (var f in formats)
+                    frameBuffer.Attach(f);
+
+                // This setter will also take care of allocating a texture of appropriate size within the framebuffer.
+                frameBuffer.Size = requestedSize;
+
+                frameBuffer.Bind();
+
+                return new ValueInvokeOnDisposal(frameBuffer.Unbind);
+            }
+
+            private void drawFrameBufferToBackBuffer(FrameBuffer frameBuffer, RectangleF drawRectangle, ColourInfo colourInfo)
+            {
+                // The strange Y coordinate and Height are a result of OpenGL coordinate systems having Y grow upwards and not downwards.
+                RectangleF textureRect = new RectangleF(0, frameBuffer.Texture.Height, frameBuffer.Texture.Width, -frameBuffer.Texture.Height);
+                if (frameBuffer.Texture.Bind())
+                    // Color was already applied by base.Draw(); no need to re-apply. Thus we use White here.
+                    frameBuffer.Texture.DrawQuad(drawRectangle, textureRect, colourInfo);
+            }
+
+            private void drawChildren(Action<TexturedVertex2D> vertexAction, Vector2 frameBufferSize)
+            {
+                // Fill the frame buffer with drawn children
+                using (bindFrameBuffer(currentFrameBuffer, frameBufferSize))
+                {
+                    // We need to draw children as if they were zero-based to the top-left of the texture.
+                    // We can do this by adding a translation component to our (orthogonal) projection matrix.
+                    GLWrapper.PushOrtho(screenSpaceDrawRectangle);
+
+                    GLWrapper.Clear(new ClearInfo(backgroundColour));
+                    base.Draw(vertexAction);
+
+                    GLWrapper.PopOrtho();
+                }
+            }
+
+            private void drawBlurredFrameBuffer(int kernelRadius, float sigma, float blurRotation)
+            {
+                FrameBuffer source = currentFrameBuffer;
+                FrameBuffer target = advanceFrameBuffer();
+
+                GLWrapper.SetBlend(new BlendingInfo(BlendingMode.None));
+
+                using (bindFrameBuffer(target, source.Size))
+                {
+                    blurShader.GetUniform<int>(@"g_Radius").UpdateValue(ref kernelRadius);
+                    blurShader.GetUniform<float>(@"g_Sigma").UpdateValue(ref sigma);
+
+                    Vector2 size = source.Size;
+                    blurShader.GetUniform<Vector2>(@"g_TexSize").UpdateValue(ref size);
+
+                    float radians = -MathHelper.DegreesToRadians(blurRotation);
+                    Vector2 blur = new Vector2((float)Math.Cos(radians), (float)Math.Sin(radians));
+                    blurShader.GetUniform<Vector2>(@"g_BlurDirection").UpdateValue(ref blur);
+
+                    blurShader.Bind();
+                    drawFrameBufferToBackBuffer(source, new RectangleF(0, 0, source.Texture.Width, source.Texture.Height), ColourInfo.SingleColour(Color4.White));
+                    blurShader.Unbind();
+                }
+            }
+
+            private int currentFrameBufferIndex;
+            private FrameBuffer currentFrameBuffer => sharedData.FrameBuffers[currentFrameBufferIndex];
+            private FrameBuffer advanceFrameBuffer() => sharedData.FrameBuffers[currentFrameBufferIndex = (currentFrameBufferIndex + 1) % 2];
+
+            /// <summary>
+            /// Makes sure the first frame buffer is always the one we want to draw from.
+            /// This saves us the need to sync the draw indices across draw node trees
+            /// since the SharedData.FrameBuffers array is already shared.
+            /// </summary>
+            private void finalizeFrameBuffer()
+            {
+                if (currentFrameBufferIndex != 0)
+                {
+                    Trace.Assert(currentFrameBufferIndex == 1,
+                        $"Only the first two framebuffers should be the last to be written to at the end of {nameof(Draw)}.");
+
+                    FrameBuffer temp = sharedData.FrameBuffers[0];
+                    sharedData.FrameBuffers[0] = sharedData.FrameBuffers[1];
+                    sharedData.FrameBuffers[1] = temp;
+
+                    currentFrameBufferIndex = 0;
+                }
+            }
+
+            // Our effects will be drawn into framebuffers 0 and 1. If we want to preserve the originally
+            // drawn children we need to put them in a separate buffer; in this case buffer 2. Otherwise,
+            // we do not want to allocate a third buffer for nothing and hence we start with 0.
+            private int originalIndex => drawOriginal && (blurRadius.X > 0 || blurRadius.Y > 0) ? 2 : 0;
+
+            public override void Draw(Action<TexturedVertex2D> vertexAction)
+            {
+                currentFrameBufferIndex = originalIndex;
+
+                Vector2 frameBufferSize = new Vector2((float)Math.Ceiling(screenSpaceDrawRectangle.Width), (float)Math.Ceiling(screenSpaceDrawRectangle.Height));
+                if (RequiresRedraw)
+                {
+                    sharedData.DrawVersion = updateVersion;
+
+                    using (establishFrameBufferViewport(frameBufferSize))
+                    {
+                        drawChildren(vertexAction, frameBufferSize);
+
+                        // Blur post-processing in case a blur radius is defined.
+                        if (blurRadius.X > 0 || blurRadius.Y > 0)
+                        {
+                            GL.Disable(EnableCap.ScissorTest);
+
+                            if (blurRadius.X > 0) drawBlurredFrameBuffer(blurRadius.X, blurSigma.X, blurRotation);
+                            if (blurRadius.Y > 0) drawBlurredFrameBuffer(blurRadius.Y, blurSigma.Y, blurRotation + 90);
+
+                            GL.Enable(EnableCap.ScissorTest);
+                        }
+                    }
+
+                    finalizeFrameBuffer();
+                }
+
+                RectangleF drawRectangle = filteringMode == All.Nearest
+                    ? new RectangleF(screenSpaceDrawRectangle.X, screenSpaceDrawRectangle.Y, frameBufferSize.X, frameBufferSize.Y)
+                    : screenSpaceDrawRectangle;
+
+                Shader.Bind();
+
+                if (drawOriginal && effectPlacement == EffectPlacement.InFront)
+                {
+                    GLWrapper.SetBlend(DrawColourInfo.Blending);
+                    drawFrameBufferToBackBuffer(sharedData.FrameBuffers[originalIndex], drawRectangle, DrawColourInfo.Colour);
+                }
+
+                // Blit the final framebuffer to screen.
+                GLWrapper.SetBlend(new BlendingInfo(effectBlending));
+
+                ColourInfo finalEffectColour = DrawColourInfo.Colour;
+                finalEffectColour.ApplyChild(effectColour);
+                drawFrameBufferToBackBuffer(sharedData.FrameBuffers[0], drawRectangle, finalEffectColour);
+
+                if (drawOriginal && effectPlacement == EffectPlacement.Behind)
+                {
+                    GLWrapper.SetBlend(DrawColourInfo.Blending);
+                    drawFrameBufferToBackBuffer(sharedData.FrameBuffers[originalIndex], drawRectangle, DrawColourInfo.Colour);
+                }
+
+                Shader.Unbind();
+            }
+        }
+
+        private class BufferedContainerDrawNodeSharedData : IDisposable
+        {
+            /// <summary>
+            /// The <see cref="FrameBuffer"/>s to render to.
+            /// These are used in a ping-pong manner to render effects <see cref="BufferedContainerDrawNode"/>.
+            /// </summary>
+            public readonly FrameBuffer[] FrameBuffers = new FrameBuffer[3];
+
+            /// <summary>
+            /// The version of drawn contents currently present in <see cref="FrameBuffers"/>.
+            /// This should only be modified by <see cref="BufferedContainerDrawNode"/>.
+            /// </summary>
+            public long DrawVersion = -1;
+
+            public BufferedContainerDrawNodeSharedData()
+            {
+                for (int i = 0; i < FrameBuffers.Length; i++)
+                    FrameBuffers[i] = new FrameBuffer();
+            }
+
+            ~BufferedContainerDrawNodeSharedData()
+            {
+                dispose();
+            }
+
+            public void Dispose()
+            {
+                dispose();
+                GC.SuppressFinalize(this);
+            }
+
+            private void dispose()
+            {
+                for (int i = 0; i < FrameBuffers.Length; i++)
+                    FrameBuffers[i].Dispose();
+            }
+        }
+    }
+}

osu.Framework/Graphics/Containers/CompositeDrawNode.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 System.Collections.Generic;
-using osu.Framework.Graphics.OpenGL;
-using osu.Framework.Graphics.Primitives;
-using osu.Framework.Graphics.Shaders;
-using osu.Framework.Graphics.Batches;
-using osuTK;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Colour;
-using System;
-using osu.Framework.Graphics.OpenGL.Vertices;
-
-namespace osu.Framework.Graphics.Containers
-{
-    /// <summary>
-    /// Types of edge effects that can be applied to <see cref="CompositeDrawable"/>s.
-    /// </summary>
-    public enum EdgeEffectType
-    {
-        None,
-        Glow,
-        Shadow,
-    }
-
-    /// <summary>
-    /// Parametrizes the appearance of an edge effect.
-    /// </summary>
-    public struct EdgeEffectParameters : IEquatable<EdgeEffectParameters>
-    {
-        /// <summary>
-        /// Colour of the edge effect.
-        /// </summary>
-        public SRGBColour Colour;
-
-        /// <summary>
-        /// Positional offset applied to the edge effect.
-        /// Useful for off-center shadows.
-        /// </summary>
-        public Vector2 Offset;
-
-        /// <summary>
-        /// The type of the edge effect.
-        /// </summary>
-        public EdgeEffectType Type;
-
-        /// <summary>
-        /// How round the edge effect should appear. Adds to the <see cref="CompositeDrawable.CornerRadius"/>
-        /// of the corresponding <see cref="CompositeDrawable"/>. Not to confuse with the <see cref="Radius"/>.
-        /// </summary>
-        public float Roundness;
-
-        /// <summary>
-        /// How "thick" the edge effect is around the <see cref="CompositeDrawable"/>. In other words: At what distance
-        /// from the <see cref="CompositeDrawable"/>'s border the edge effect becomes fully invisible.
-        /// </summary>
-        public float Radius;
-
-        /// <summary>
-        /// Whether the inside of the EdgeEffect rectangle should be empty.
-        /// </summary>
-        public bool Hollow;
-
-        public bool Equals(EdgeEffectParameters other) =>
-            Colour.Equals(other.Colour) &&
-            Offset == other.Offset &&
-            Type == other.Type &&
-            Roundness == other.Roundness &&
-            Radius == other.Radius;
-
-        public override string ToString() => Type != EdgeEffectType.None ? $@"{Radius} {Type}EdgeEffect" : @"EdgeEffect (Disabled)";
-    }
-
-    /// <summary>
-    /// A draw node responsible for rendering a <see cref="CompositeDrawable"/> and the
-    /// <see cref="DrawNode"/>s of its children.
-    /// </summary>
-    public class CompositeDrawNode : DrawNode
-    {
-        /// <summary>
-        /// The <see cref="DrawNode"/>s of the children of our <see cref="CompositeDrawable"/>.
-        /// </summary>
-        public List<DrawNode> Children;
-
-        /// <summary>
-        /// Information about how masking of children should be carried out.
-        /// </summary>
-        public MaskingInfo? MaskingInfo;
-
-        /// <summary>
-        /// The screen-space version of <see cref="OpenGL.MaskingInfo.MaskingRect"/>.
-        /// Used as cache of screen-space masking quads computed in previous frames.
-        /// Assign null to reset.
-        /// </summary>
-        public Quad? ScreenSpaceMaskingQuad;
-
-        /// <summary>
-        /// Information about how the edge effect should be rendered.
-        /// </summary>
-        public EdgeEffectParameters EdgeEffect;
-
-        /// <summary>
-        /// The shader to use for rendering.
-        /// </summary>
-        public IShader Shader;
-
-        /// <summary>
-        /// Whether to use a local vertex batch for rendering. If false, a parenting vertex batch will be used.
-        /// </summary>
-        public bool ForceLocalVertexBatch;
-
-        /// <summary>
-        /// The vertex batch used for rendering.
-        /// </summary>
-        private QuadBatch<TexturedVertex2D> vertexBatch;
-
-        private void drawEdgeEffect()
-        {
-            if (MaskingInfo == null || EdgeEffect.Type == EdgeEffectType.None || EdgeEffect.Radius <= 0.0f || EdgeEffect.Colour.Linear.A <= 0.0f)
-                return;
-
-            RectangleF effectRect = MaskingInfo.Value.MaskingRect.Inflate(EdgeEffect.Radius).Offset(EdgeEffect.Offset);
-            if (!ScreenSpaceMaskingQuad.HasValue)
-                ScreenSpaceMaskingQuad = Quad.FromRectangle(effectRect) * DrawInfo.Matrix;
-
-            MaskingInfo edgeEffectMaskingInfo = MaskingInfo.Value;
-            edgeEffectMaskingInfo.MaskingRect = effectRect;
-            edgeEffectMaskingInfo.ScreenSpaceAABB = ScreenSpaceMaskingQuad.Value.AABB;
-            edgeEffectMaskingInfo.CornerRadius = MaskingInfo.Value.CornerRadius + EdgeEffect.Radius + EdgeEffect.Roundness;
-            edgeEffectMaskingInfo.BorderThickness = 0;
-            // HACK HACK HACK. We abuse blend range to give us the linear alpha gradient of
-            // the edge effect along its radius using the same rounded-corners shader.
-            edgeEffectMaskingInfo.BlendRange = EdgeEffect.Radius;
-            edgeEffectMaskingInfo.AlphaExponent = 2;
-            edgeEffectMaskingInfo.EdgeOffset = EdgeEffect.Offset;
-            edgeEffectMaskingInfo.Hollow = EdgeEffect.Hollow;
-            edgeEffectMaskingInfo.HollowCornerRadius = MaskingInfo.Value.CornerRadius + EdgeEffect.Radius;
-
-            GLWrapper.PushMaskingInfo(edgeEffectMaskingInfo);
-
-            GLWrapper.SetBlend(new BlendingInfo(EdgeEffect.Type == EdgeEffectType.Glow ? BlendingMode.Additive : BlendingMode.Mixture));
-
-            Shader.Bind();
-
-            ColourInfo colour = ColourInfo.SingleColour(EdgeEffect.Colour);
-            colour.TopLeft.MultiplyAlpha(DrawColourInfo.Colour.TopLeft.Linear.A);
-            colour.BottomLeft.MultiplyAlpha(DrawColourInfo.Colour.BottomLeft.Linear.A);
-            colour.TopRight.MultiplyAlpha(DrawColourInfo.Colour.TopRight.Linear.A);
-            colour.BottomRight.MultiplyAlpha(DrawColourInfo.Colour.BottomRight.Linear.A);
-
-            Texture.WhitePixel.DrawQuad(
-                ScreenSpaceMaskingQuad.Value,
-                colour, null, null, null,
-                // HACK HACK HACK. We re-use the unused vertex blend range to store the original
-                // masking blend range when rendering edge effects. This is needed for smooth inner edges
-                // with a hollow edge effect.
-                new Vector2(MaskingInfo.Value.BlendRange));
-
-            Shader.Unbind();
-
-            GLWrapper.PopMaskingInfo();
-        }
-
-        private const int min_amount_children_to_warrant_batch = 5;
-
-        private bool mayHaveOwnVertexBatch(int amountChildren) => ForceLocalVertexBatch || amountChildren >= min_amount_children_to_warrant_batch;
-
-        private void updateVertexBatch()
-        {
-            if (Children == null)
-                return;
-
-            // This logic got roughly copied from the old osu! code base. These constants seem to have worked well so far.
-            int clampedAmountChildren = MathHelper.Clamp(Children.Count, 1, 1000);
-            if (mayHaveOwnVertexBatch(clampedAmountChildren) && (vertexBatch == null || vertexBatch.Size < clampedAmountChildren))
-                vertexBatch = new QuadBatch<TexturedVertex2D>(clampedAmountChildren * 2, 500);
-        }
-
-        public override void Draw(Action<TexturedVertex2D> vertexAction)
-        {
-            updateVertexBatch();
-
-            // Prefer to use own vertex batch instead of the parent-owned one.
-            if (vertexBatch != null)
-                vertexAction = vertexBatch.AddAction;
-
-            base.Draw(vertexAction);
-
-            drawEdgeEffect();
-            if (MaskingInfo != null)
-            {
-                MaskingInfo info = MaskingInfo.Value;
-                if (info.BorderThickness > 0)
-                    info.BorderColour *= DrawColourInfo.Colour.AverageColour;
-
-                GLWrapper.PushMaskingInfo(info);
-            }
-
-            if (Children != null)
-                for (int i = 0; i < Children.Count; i++)
-                    Children[i].Draw(vertexAction);
-
-            if (MaskingInfo != null)
-                GLWrapper.PopMaskingInfo();
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            vertexBatch?.Dispose();
-        }
-    }
-}

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
 using System.Linq;
 using System.Threading;
 using osuTK;
-using osu.Framework.Graphics.OpenGL;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Shaders;
 using osu.Framework.Extensions.IEnumerableExtensions;
···
 using System.Threading.Tasks;
 using osu.Framework.Development;
 using osu.Framework.Extensions.ExceptionExtensions;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.MathUtils;
 
···
     /// Additionally, <see cref="CompositeDrawable"/>s support various effects, such as masking, edge effect,
     /// padding, and automatic sizing depending on their children.
     /// </summary>
-    public abstract class CompositeDrawable : Drawable
+    public abstract partial class CompositeDrawable : Drawable
     {
         #region Contruction and disposal
 
···
         [BackgroundDependencyLoader(true)]
         private void load(ShaderManager shaders, CancellationToken? cancellation)
         {
-            if (shader == null)
-                shader = shaders?.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
+            if (Shader == null)
+                Shader = shaders?.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
 
             // We are in a potentially async context, so let's aggressively load all our children
             // regardless of their alive state. this also gives children a clock so they can be checked
···
 
         #region DrawNode
 
-        private IShader shader;
-
-        protected override DrawNode CreateDrawNode() => new CompositeDrawNode();
-
-        protected override void ApplyDrawNode(DrawNode node)
-        {
-            CompositeDrawNode n = (CompositeDrawNode)node;
-
-            if (!Masking && (BorderThickness != 0.0f || EdgeEffect.Type != EdgeEffectType.None))
-                throw new InvalidOperationException("Can not have border effects/edge effects if masking is disabled.");
-
-            Vector3 scale = DrawInfo.MatrixInverse.ExtractScale();
-
-            n.MaskingInfo = !Masking
-                ? (MaskingInfo?)null
-                : new MaskingInfo
-                {
-                    ScreenSpaceAABB = ScreenSpaceDrawQuad.AABB,
-                    MaskingRect = DrawRectangle,
-                    ToMaskingSpace = DrawInfo.MatrixInverse,
-                    CornerRadius = CornerRadius,
-                    BorderThickness = BorderThickness,
-                    BorderColour = BorderColour,
-                    // We are setting the linear blend range to the approximate size of a _pixel_ here.
-                    // This results in the optimal trade-off between crispness and smoothness of the
-                    // edges of the masked region according to sampling theory.
-                    BlendRange = MaskingSmoothness * (scale.X + scale.Y) / 2,
-                    AlphaExponent = 1,
-                };
+        internal IShader Shader { get; private set; }
 
-            n.EdgeEffect = EdgeEffect;
-            n.ScreenSpaceMaskingQuad = null;
-            n.Shader = shader;
-            n.ForceLocalVertexBatch = ForceLocalVertexBatch;
-
-            base.ApplyDrawNode(node);
-        }
+        protected override DrawNode CreateDrawNode() => new CompositeDrawableDrawNode(this);
 
         private bool forceLocalVertexBatch;
 
···
             }
         }
 
-        internal virtual bool AddChildDrawNodes => true;
-
         internal override DrawNode GenerateDrawNodeSubtree(ulong frame, int treeIndex, bool forceNewDrawNode)
         {
             // No need for a draw node at all if there are no children and we are not glowing.
             if (aliveInternalChildren.Count == 0 && CanBeFlattened)
                 return null;
 
-            if (!(base.GenerateDrawNodeSubtree(frame, treeIndex, forceNewDrawNode) is CompositeDrawNode cNode))
+            DrawNode node = base.GenerateDrawNodeSubtree(frame, treeIndex, forceNewDrawNode);
+
+            if (!(node is ICompositeDrawNode cNode))
                 return null;
 
             if (cNode.Children == null)
                 cNode.Children = new List<DrawNode>(aliveInternalChildren.Count);
 
-            if (AddChildDrawNodes)
+            if (cNode.AddChildDrawNodes)
             {
-                List<DrawNode> target = cNode.Children;
-
                 int j = 0;
-                addFromComposite(frame, treeIndex, forceNewDrawNode, ref j, this, target);
+                addFromComposite(frame, treeIndex, forceNewDrawNode, ref j, this, cNode.Children);
 
-                if (j < target.Count)
-                    target.RemoveRange(j, target.Count - j);
+                if (j < cNode.Children.Count)
+                    cNode.Children.RemoveRange(j, cNode.Children.Count - j);
             }
 
-            return cNode;
+            return node;
         }
 
         #endregion

osu.Framework/Graphics/Containers/CompositeDrawable_DrawNode.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 System.Collections.Generic;
+using osu.Framework.Graphics.OpenGL;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Shaders;
+using osu.Framework.Graphics.Batches;
+using osuTK;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Graphics.Colour;
+using System;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.OpenGL.Vertices;
+
+namespace osu.Framework.Graphics.Containers
+{
+    public partial class CompositeDrawable
+    {
+        /// <summary>
+        /// A draw node responsible for rendering a <see cref="CompositeDrawable"/> and the <see cref="DrawNode"/>s of its children.
+        /// </summary>
+        protected class CompositeDrawableDrawNode : DrawNode, ICompositeDrawNode
+        {
+            protected new CompositeDrawable Source => (CompositeDrawable)base.Source;
+
+            /// <summary>
+            /// The <see cref="IShader"/> to use for rendering.
+            /// </summary>
+            protected IShader Shader { get; private set; }
+
+            /// <summary>
+            /// The <see cref="DrawNode"/>s of the children of our <see cref="CompositeDrawable"/>.
+            /// </summary>
+            public List<DrawNode> Children { get; set; }
+
+            /// <summary>
+            /// Information about how masking of children should be carried out.
+            /// </summary>
+            private MaskingInfo? maskingInfo;
+
+            /// <summary>
+            /// The screen-space version of <see cref="OpenGL.MaskingInfo.MaskingRect"/>.
+            /// Used as cache of screen-space masking quads computed in previous frames.
+            /// Assign null to reset.
+            /// </summary>
+            private Quad? screenSpaceMaskingQuad;
+
+            /// <summary>
+            /// Information about how the edge effect should be rendered.
+            /// </summary>
+            private EdgeEffectParameters edgeEffect;
+
+            /// <summary>
+            /// Whether to use a local vertex batch for rendering. If false, a parenting vertex batch will be used.
+            /// </summary>
+            private bool forceLocalVertexBatch;
+
+            /// <summary>
+            /// The vertex batch used for rendering.
+            /// </summary>
+            private QuadBatch<TexturedVertex2D> vertexBatch;
+
+            public CompositeDrawableDrawNode(CompositeDrawable source)
+                : base(source)
+            {
+            }
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                if (!Source.Masking && (Source.BorderThickness != 0.0f || edgeEffect.Type != EdgeEffectType.None))
+                    throw new InvalidOperationException("Can not have border effects/edge effects if masking is disabled.");
+
+                Vector3 scale = DrawInfo.MatrixInverse.ExtractScale();
+
+                maskingInfo = !Source.Masking
+                    ? (MaskingInfo?)null
+                    : new MaskingInfo
+                    {
+                        ScreenSpaceAABB = Source.ScreenSpaceDrawQuad.AABB,
+                        MaskingRect = Source.DrawRectangle,
+                        ToMaskingSpace = DrawInfo.MatrixInverse,
+                        CornerRadius = Source.CornerRadius,
+                        BorderThickness = Source.BorderThickness,
+                        BorderColour = Source.BorderColour,
+                        // We are setting the linear blend range to the approximate size of a _pixel_ here.
+                        // This results in the optimal trade-off between crispness and smoothness of the
+                        // edges of the masked region according to sampling theory.
+                        BlendRange = Source.MaskingSmoothness * (scale.X + scale.Y) / 2,
+                        AlphaExponent = 1,
+                    };
+
+                edgeEffect = Source.EdgeEffect;
+                screenSpaceMaskingQuad = null;
+                Shader = Source.Shader;
+                forceLocalVertexBatch = Source.ForceLocalVertexBatch;
+            }
+
+            public virtual bool AddChildDrawNodes => true;
+
+            private void drawEdgeEffect()
+            {
+                if (maskingInfo == null || edgeEffect.Type == EdgeEffectType.None || edgeEffect.Radius <= 0.0f || edgeEffect.Colour.Linear.A <= 0.0f)
+                    return;
+
+                RectangleF effectRect = maskingInfo.Value.MaskingRect.Inflate(edgeEffect.Radius).Offset(edgeEffect.Offset);
+
+                if (!screenSpaceMaskingQuad.HasValue)
+                    screenSpaceMaskingQuad = Quad.FromRectangle(effectRect) * DrawInfo.Matrix;
+
+                MaskingInfo edgeEffectMaskingInfo = maskingInfo.Value;
+                edgeEffectMaskingInfo.MaskingRect = effectRect;
+                edgeEffectMaskingInfo.ScreenSpaceAABB = screenSpaceMaskingQuad.Value.AABB;
+                edgeEffectMaskingInfo.CornerRadius = maskingInfo.Value.CornerRadius + edgeEffect.Radius + edgeEffect.Roundness;
+                edgeEffectMaskingInfo.BorderThickness = 0;
+                // HACK HACK HACK. We abuse blend range to give us the linear alpha gradient of
+                // the edge effect along its radius using the same rounded-corners shader.
+                edgeEffectMaskingInfo.BlendRange = edgeEffect.Radius;
+                edgeEffectMaskingInfo.AlphaExponent = 2;
+                edgeEffectMaskingInfo.EdgeOffset = edgeEffect.Offset;
+                edgeEffectMaskingInfo.Hollow = edgeEffect.Hollow;
+                edgeEffectMaskingInfo.HollowCornerRadius = maskingInfo.Value.CornerRadius + edgeEffect.Radius;
+
+                GLWrapper.PushMaskingInfo(edgeEffectMaskingInfo);
+
+                GLWrapper.SetBlend(new BlendingInfo(edgeEffect.Type == EdgeEffectType.Glow ? BlendingMode.Additive : BlendingMode.Mixture));
+
+                Shader.Bind();
+
+                ColourInfo colour = ColourInfo.SingleColour(edgeEffect.Colour);
+                colour.TopLeft.MultiplyAlpha(DrawColourInfo.Colour.TopLeft.Linear.A);
+                colour.BottomLeft.MultiplyAlpha(DrawColourInfo.Colour.BottomLeft.Linear.A);
+                colour.TopRight.MultiplyAlpha(DrawColourInfo.Colour.TopRight.Linear.A);
+                colour.BottomRight.MultiplyAlpha(DrawColourInfo.Colour.BottomRight.Linear.A);
+
+                Texture.WhitePixel.DrawQuad(
+                    screenSpaceMaskingQuad.Value,
+                    colour, null, null, null,
+                    // HACK HACK HACK. We re-use the unused vertex blend range to store the original
+                    // masking blend range when rendering edge effects. This is needed for smooth inner edges
+                    // with a hollow edge effect.
+                    new Vector2(maskingInfo.Value.BlendRange));
+
+                Shader.Unbind();
+
+                GLWrapper.PopMaskingInfo();
+            }
+
+            private const int min_amount_children_to_warrant_batch = 5;
+
+            private bool mayHaveOwnVertexBatch(int amountChildren) => forceLocalVertexBatch || amountChildren >= min_amount_children_to_warrant_batch;
+
+            private void updateVertexBatch()
+            {
+                if (Children == null)
+                    return;
+
+                // This logic got roughly copied from the old osu! code base. These constants seem to have worked well so far.
+                int clampedAmountChildren = MathHelper.Clamp(Children.Count, 1, 1000);
+                if (mayHaveOwnVertexBatch(clampedAmountChildren) && (vertexBatch == null || vertexBatch.Size < clampedAmountChildren))
+                    vertexBatch = new QuadBatch<TexturedVertex2D>(clampedAmountChildren * 2, 500);
+            }
+
+            public override void Draw(Action<TexturedVertex2D> vertexAction)
+            {
+                updateVertexBatch();
+
+                // Prefer to use own vertex batch instead of the parent-owned one.
+                if (vertexBatch != null)
+                    vertexAction = vertexBatch.AddAction;
+
+                base.Draw(vertexAction);
+
+                drawEdgeEffect();
+                if (maskingInfo != null)
+                {
+                    MaskingInfo info = maskingInfo.Value;
+                    if (info.BorderThickness > 0)
+                        info.BorderColour *= DrawColourInfo.Colour.AverageColour;
+
+                    GLWrapper.PushMaskingInfo(info);
+                }
+
+                if (Children != null)
+                    for (int i = 0; i < Children.Count; i++)
+                        Children[i].Draw(vertexAction);
+
+                if (maskingInfo != null)
+                    GLWrapper.PopMaskingInfo();
+            }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                vertexBatch?.Dispose();
+            }
+        }
+    }
+}

osu.Framework/Graphics/Containers/Container.cs

···
 using osuTK;
 using System.Collections;
 using System.Diagnostics;
+using osu.Framework.Graphics.Effects;
 
 namespace osu.Framework.Graphics.Containers
 {

osu.Framework/Graphics/Containers/IContainer.cs

···
 using osuTK;
 using System;
 using System.Collections.Generic;
+using osu.Framework.Graphics.Effects;
 
 namespace osu.Framework.Graphics.Containers
 {

osu.Framework/Graphics/Cursor/CursorContainer.cs

···
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;

osu.Framework/Graphics/DrawNode.cs

···
 {
     /// <summary>
     /// Contains all the information required to draw a single <see cref="Drawable"/>.
-    /// A hierarchy of DrawNodes is passed to the draw thread for rendering every frame.
+    /// A hierarchy of <see cref="DrawNode"/>s is passed to the draw thread for rendering every frame.
     /// </summary>
     public class DrawNode : IDisposable
     {
         /// <summary>
-        /// Contains a linear transformation, colour information, and blending information
-        /// of this draw node.
+        /// Contains the linear transformation of this <see cref="DrawNode"/>.
         /// </summary>
-        public DrawInfo DrawInfo { get; internal set; }
+        protected DrawInfo DrawInfo { get; private set; }
 
-        public DrawColourInfo DrawColourInfo { get; internal set; }
+        /// <summary>
+        /// Contains the colour and blending information of this <see cref="DrawNode"/>.
+        /// </summary>
+        protected internal DrawColourInfo DrawColourInfo { get; internal set; }
 
         /// <summary>
         /// Identifies the state of this draw node with an invalidation state of its corresponding
-        /// <see cref="Drawable"/>. Whenever the invalidation state of this draw node disagrees
-        /// with the state of its <see cref="Drawable"/> it has to be updated.
+        /// <see cref="Drawable"/>. An update is required when the invalidation state of this draw node disagrees
+        /// with the invalidation state of its <see cref="Drawable"/>.
+        /// </summary>
+        protected internal long InvalidationID { get; private set; }
+
+        /// <summary>
+        /// The <see cref="Drawable"/> which this <see cref="DrawNode"/> draws.
+        /// </summary>
+        protected readonly IDrawable Source;
+
+        /// <summary>
+        /// Creates a new <see cref="DrawNode"/>.
+        /// </summary>
+        /// <param name="source">The <see cref="Drawable"/> to draw with this <see cref="DrawNode"/>.</param>
+        public DrawNode(IDrawable source)
+        {
+            Source = source;
+        }
+
+        /// <summary>
+        /// Applies the state of <see cref="Source"/> to this <see cref="DrawNode"/> for use in rendering.
+        /// The applied state must remain immutable.
         /// </summary>
-        public long InvalidationID { get; internal set; }
+        public virtual void ApplyState()
+        {
+            DrawInfo = Source.DrawInfo;
+            DrawColourInfo = Source.DrawColourInfo;
+            InvalidationID = Source.InvalidationID;
+        }
 
         /// <summary>
         /// Draws this draw node to the screen.

osu.Framework/Graphics/Drawable.cs

···
         private static readonly AtomicCounter invalidation_counter = new AtomicCounter();
 
         // Make sure we start out with a value of 1 such that ApplyDrawNode is always called at least once
-        private long invalidationID = invalidation_counter.Increment();
+        public long InvalidationID { get; private set; } = invalidation_counter.Increment();
 
         /// <summary>
         /// Invalidates draw matrix and autosize caches.
···
                 alreadyInvalidated &= !drawColourInfoBacking.Invalidate();
 
             if (!alreadyInvalidated || (invalidation & Invalidation.DrawNode) > 0)
-                invalidationID = invalidation_counter.Increment();
+                InvalidationID = invalidation_counter.Increment();
 
             OnInvalidate?.Invoke(this);
 
···
                 FrameStatistics.Increment(StatisticsCounterType.DrawNodeCtor);
             }
 
-            if (invalidationID != node.InvalidationID)
+            if (InvalidationID != node.InvalidationID)
             {
-                ApplyDrawNode(node);
+                node.ApplyState();
                 FrameStatistics.Increment(StatisticsCounterType.DrawNodeAppl);
             }
 
···
         }
 
         /// <summary>
-        /// Fills a given draw node with all information required to draw this drawable.
-        /// </summary>
-        /// <param name="node">The node to fill with information.</param>
-        protected virtual void ApplyDrawNode(DrawNode node)
-        {
-            node.DrawInfo = DrawInfo;
-            node.DrawColourInfo = DrawColourInfo;
-            node.InvalidationID = invalidationID;
-        }
-
-        /// <summary>
         /// Creates a draw node capable of containing all information required to draw this drawable.
         /// </summary>
         /// <returns>The created draw node.</returns>
-        protected virtual DrawNode CreateDrawNode() => new DrawNode();
+        protected virtual DrawNode CreateDrawNode() => new DrawNode(this);
 
         #endregion
 
···
         Colour = 1 << 3,
 
         /// <summary>
-        /// <see cref="Drawable.ApplyDrawNode(Graphics.DrawNode)"/> has to be invoked on all old draw nodes.
+        /// <see cref="Graphics.DrawNode.ApplyState"/> has to be invoked on all old draw nodes.
         /// </summary>
         DrawNode = 1 << 4,
 

osu.Framework/Graphics/Drawable_ProxyDrawable.cs

···
                 /// </summary>
                 public ulong FrameCount;
 
-                private readonly ProxyDrawable proxyDrawable;
+                protected new ProxyDrawable Source => (ProxyDrawable)base.Source;
 
                 public ProxyDrawNode(ProxyDrawable proxyDrawable)
+                    : base(proxyDrawable)
                 {
-                    this.proxyDrawable = proxyDrawable;
                 }
 
                 public override void Draw(Action<TexturedVertex2D> vertexAction)
                 {
-                    var target = proxyDrawable.originalDrawNodes[DrawNodeIndex];
+                    var target = Source.originalDrawNodes[DrawNodeIndex];
                     if (target == null)
                         return;
 
-                    if (proxyDrawable.drawNodeValidationIds[DrawNodeIndex] != FrameCount)
+                    if (Source.drawNodeValidationIds[DrawNodeIndex] != FrameCount)
                         return;
 
                     target.Draw(vertexAction);

osu.Framework/Graphics/Effects/EdgeEffectParameters.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 System;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osuTK;
+
+namespace osu.Framework.Graphics.Effects
+{
+    /// <summary>
+    /// Parametrizes the appearance of an edge effect.
+    /// </summary>
+    public struct EdgeEffectParameters : IEquatable<EdgeEffectParameters>
+    {
+        /// <summary>
+        /// Colour of the edge effect.
+        /// </summary>
+        public SRGBColour Colour;
+
+        /// <summary>
+        /// Positional offset applied to the edge effect.
+        /// Useful for off-center shadows.
+        /// </summary>
+        public Vector2 Offset;
+
+        /// <summary>
+        /// The type of the edge effect.
+        /// </summary>
+        public EdgeEffectType Type;
+
+        /// <summary>
+        /// How round the edge effect should appear. Adds to the <see cref="CompositeDrawable.CornerRadius"/>
+        /// of the corresponding <see cref="CompositeDrawable"/>. Not to confuse with the <see cref="Radius"/>.
+        /// </summary>
+        public float Roundness;
+
+        /// <summary>
+        /// How "thick" the edge effect is around the <see cref="CompositeDrawable"/>. In other words: At what distance
+        /// from the <see cref="CompositeDrawable"/>'s border the edge effect becomes fully invisible.
+        /// </summary>
+        public float Radius;
+
+        /// <summary>
+        /// Whether the inside of the EdgeEffect rectangle should be empty.
+        /// </summary>
+        public bool Hollow;
+
+        public bool Equals(EdgeEffectParameters other) =>
+            Colour.Equals(other.Colour) &&
+            Offset == other.Offset &&
+            Type == other.Type &&
+            Roundness == other.Roundness &&
+            Radius == other.Radius;
+
+        public override string ToString() => Type != EdgeEffectType.None ? $@"{Radius} {Type}EdgeEffect" : @"EdgeEffect (Disabled)";
+    }
+}

osu.Framework/Graphics/Effects/EdgeEffectType.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 osu.Framework.Graphics.Containers;
+
+namespace osu.Framework.Graphics.Effects
+{
+    /// <summary>
+    /// Types of edge effects that can be applied to <see cref="CompositeDrawable"/>s.
+    /// </summary>
+    public enum EdgeEffectType
+    {
+        None,
+        Glow,
+        Shadow,
+    }
+}

osu.Framework/Graphics/ICompositeDrawNode.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 System.Collections.Generic;
+using osu.Framework.Graphics.Containers;
+
+namespace osu.Framework.Graphics
+{
+    /// <summary>
+    /// Interface for <see cref="DrawNode"/>s which compose child <see cref="DrawNode"/>s.
+    /// <see cref="DrawNode"/>s implementing this interface can be used in <see cref="CompositeDrawable"/>s.
+    /// </summary>
+    public interface ICompositeDrawNode
+    {
+        /// <summary>
+        /// The child <see cref="DrawNode"/>s to draw.
+        /// </summary>
+        List<DrawNode> Children { get; set; }
+
+        /// <summary>
+        /// Whether <see cref="Children"/> should be updated by the parenting <see cref="CompositeDrawable"/>.
+        /// </summary>
+        bool AddChildDrawNodes { get; }
+    }
+}

osu.Framework/Graphics/IDrawable.cs

···
         DrawInfo DrawInfo { get; }
 
         /// <summary>
+        /// Contains the colour and blending information of this <see cref="Drawable"/> that are used during draw.
+        /// </summary>
+        DrawColourInfo DrawColourInfo { get; }
+
+        /// <summary>
         /// The screen-space quad this drawable occupies.
         /// </summary>
         Quad ScreenSpaceDrawQuad { get; }
···
         /// Hide sprite instantly.
         /// </summary>
         void Hide();
+
+        /// <summary>
+        /// The current invalidation ID of this <see cref="Drawable"/>.
+        /// Incremented every time the <see cref="DrawNode"/> should be re-validated.
+        /// </summary>
+        long InvalidationID { get; }
     }
 }

osu.Framework/Graphics/ITexturedShaderDrawable.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 osu.Framework.Graphics.Shaders;
+
+namespace osu.Framework.Graphics
+{
+    /// <summary>
+    /// Interface for <see cref="Drawable"/>s which can be drawn by <see cref="TexturedShaderDrawNode"/>s.
+    /// </summary>
+    public interface ITexturedShaderDrawable : IDrawable
+    {
+        /// <summary>
+        /// The <see cref="IShader"/> to be used for rendering when masking is not required.
+        /// </summary>
+        IShader TextureShader { get; }
+
+        /// <summary>
+        /// The <see cref="IShader"/> to be used for rendering when masking is required.
+        /// </summary>
+        IShader RoundedTextureShader { get; }
+    }
+}

osu.Framework/Graphics/Lines/Path.cs

···
 using osu.Framework.Graphics.Shaders;
 using osu.Framework.Allocation;
 using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Caching;
 
 namespace osu.Framework.Graphics.Lines
 {
-    public class Path : Drawable
+    public partial class Path : Drawable, ITexturedShaderDrawable
     {
-        private IShader roundedTextureShader;
-        private IShader textureShader;
+        public IShader RoundedTextureShader { get; private set; }
+        public IShader TextureShader { get; private set; }
 
         [BackgroundDependencyLoader]
         private void load(ShaderManager shaders)
         {
-            roundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE_ROUNDED);
-            textureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE);
+            RoundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE_ROUNDED);
+            TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE);
         }
 
         private readonly List<Vector2> vertices = new List<Vector2>();
···
             }
         }
 
-        protected override DrawNode CreateDrawNode() => new PathDrawNode();
-
-        protected override void ApplyDrawNode(DrawNode node)
-        {
-            PathDrawNode n = (PathDrawNode)node;
-
-            n.Texture = Texture;
-            n.TextureShader = textureShader;
-            n.RoundedTextureShader = roundedTextureShader;
-            n.Radius = PathRadius;
-            n.DrawSize = DrawSize;
-
-            n.Segments = segments.ToList();
-
-            base.ApplyDrawNode(node);
-        }
+        protected override DrawNode CreateDrawNode() => new PathDrawNode(this);
     }
 }

osu.Framework/Graphics/Lines/PathDrawNode.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 osu.Framework.Graphics.Primitives;
-using osu.Framework.Graphics.Shaders;
-using osu.Framework.Graphics.Textures;
-using osuTK.Graphics.ES30;
-using osu.Framework.Graphics.OpenGL;
-using osuTK;
-using System;
-using System.Collections.Generic;
-using osu.Framework.Graphics.Batches;
-using osu.Framework.Graphics.OpenGL.Vertices;
-using osuTK.Graphics;
-
-namespace osu.Framework.Graphics.Lines
-{
-    public class PathDrawNode : DrawNode
-    {
-        public const int MAX_RES = 24;
-
-        public List<Line> Segments;
-
-        public Vector2 DrawSize;
-        public float Radius;
-        public Texture Texture;
-
-        public IShader TextureShader;
-        public IShader RoundedTextureShader;
-
-        // We multiply the size param by 3 such that the amount of vertices is a multiple of the amount of vertices
-        // per primitive (triangles in this case). Otherwise overflowing the batch will result in wrong
-        // grouping of vertices into primitives.
-        private readonly LinearBatch<TexturedVertex3D> halfCircleBatch = new LinearBatch<TexturedVertex3D>(MAX_RES * 100 * 3, 10, PrimitiveType.Triangles);
-        private readonly QuadBatch<TexturedVertex3D> quadBatch = new QuadBatch<TexturedVertex3D>(200, 10);
-
-        private bool needsRoundedShader => GLWrapper.IsMaskingActive;
-
-        private Vector2 pointOnCircle(float angle) => new Vector2((float)Math.Sin(angle), -(float)Math.Cos(angle));
-
-        private Vector2 relativePosition(Vector2 localPos) => Vector2.Divide(localPos, DrawSize);
-
-        private Color4 colourAt(Vector2 localPos) => DrawColourInfo.Colour.HasSingleColour
-            ? (Color4)DrawColourInfo.Colour
-            : DrawColourInfo.Colour.Interpolate(relativePosition(localPos)).Linear;
-
-        private void addLineCap(Vector2 origin, float theta, float thetaDiff, RectangleF texRect)
-        {
-            const float step = MathHelper.Pi / MAX_RES;
-
-            float dir = Math.Sign(thetaDiff);
-            thetaDiff = dir * thetaDiff;
-
-            int amountPoints = (int)Math.Ceiling(thetaDiff / step);
-
-            if (dir < 0)
-                theta += MathHelper.Pi;
-
-            Vector2 current = origin + pointOnCircle(theta) * Radius;
-            Color4 currentColour = colourAt(current);
-            current = Vector2Extensions.Transform(current, DrawInfo.Matrix);
-
-            Vector2 screenOrigin = Vector2Extensions.Transform(origin, DrawInfo.Matrix);
-            Color4 originColour = colourAt(origin);
-
-            for (int i = 1; i <= amountPoints; i++)
-            {
-                // Center point
-                halfCircleBatch.Add(new TexturedVertex3D
-                {
-                    Position = new Vector3(screenOrigin.X, screenOrigin.Y, 1),
-                    TexturePosition = new Vector2(texRect.Right, texRect.Centre.Y),
-                    Colour = originColour
-                });
-
-                // First outer point
-                halfCircleBatch.Add(new TexturedVertex3D
-                {
-                    Position = new Vector3(current.X, current.Y, 0),
-                    TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
-                    Colour = currentColour
-                });
-
-                float angularOffset = Math.Min(i * step, thetaDiff);
-                current = origin + pointOnCircle(theta + dir * angularOffset) * Radius;
-                currentColour = colourAt(current);
-                current = Vector2Extensions.Transform(current, DrawInfo.Matrix);
-
-                // Second outer point
-                halfCircleBatch.Add(new TexturedVertex3D
-                {
-                    Position = new Vector3(current.X, current.Y, 0),
-                    TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
-                    Colour = currentColour
-                });
-            }
-        }
-
-        private void addLineQuads(Line line, RectangleF texRect)
-        {
-            Vector2 ortho = line.OrthogonalDirection;
-            Line lineLeft = new Line(line.StartPoint + ortho * Radius, line.EndPoint + ortho * Radius);
-            Line lineRight = new Line(line.StartPoint - ortho * Radius, line.EndPoint - ortho * Radius);
-
-            Line screenLineLeft = new Line(Vector2Extensions.Transform(lineLeft.StartPoint, DrawInfo.Matrix), Vector2Extensions.Transform(lineLeft.EndPoint, DrawInfo.Matrix));
-            Line screenLineRight = new Line(Vector2Extensions.Transform(lineRight.StartPoint, DrawInfo.Matrix), Vector2Extensions.Transform(lineRight.EndPoint, DrawInfo.Matrix));
-            Line screenLine = new Line(Vector2Extensions.Transform(line.StartPoint, DrawInfo.Matrix), Vector2Extensions.Transform(line.EndPoint, DrawInfo.Matrix));
-
-            quadBatch.Add(new TexturedVertex3D
-            {
-                Position = new Vector3(screenLineRight.EndPoint.X, screenLineRight.EndPoint.Y, 0),
-                TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
-                Colour = colourAt(lineRight.EndPoint)
-            });
-            quadBatch.Add(new TexturedVertex3D
-            {
-                Position = new Vector3(screenLineRight.StartPoint.X, screenLineRight.StartPoint.Y, 0),
-                TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
-                Colour = colourAt(lineRight.StartPoint)
-            });
-
-            // Each "quad" of the slider is actually rendered as 2 quads, being split in half along the approximating line.
-            // On this line the depth is 1 instead of 0, which is done properly handle self-overlap using the depth buffer.
-            // Thus the middle vertices need to be added twice (once for each quad).
-            Vector3 firstMiddlePoint = new Vector3(screenLine.StartPoint.X, screenLine.StartPoint.Y, 1);
-            Vector3 secondMiddlePoint = new Vector3(screenLine.EndPoint.X, screenLine.EndPoint.Y, 1);
-            Color4 firstMiddleColour = colourAt(line.StartPoint);
-            Color4 secondMiddleColour = colourAt(line.EndPoint);
-
-            for (int i = 0; i < 2; ++i)
-            {
-                quadBatch.Add(new TexturedVertex3D
-                {
-                    Position = firstMiddlePoint,
-                    TexturePosition = new Vector2(texRect.Right, texRect.Centre.Y),
-                    Colour = firstMiddleColour
-                });
-                quadBatch.Add(new TexturedVertex3D
-                {
-                    Position = secondMiddlePoint,
-                    TexturePosition = new Vector2(texRect.Right, texRect.Centre.Y),
-                    Colour = secondMiddleColour
-                });
-            }
-
-            quadBatch.Add(new TexturedVertex3D
-            {
-                Position = new Vector3(screenLineLeft.EndPoint.X, screenLineLeft.EndPoint.Y, 0),
-                TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
-                Colour = colourAt(lineLeft.EndPoint)
-            });
-            quadBatch.Add(new TexturedVertex3D
-            {
-                Position = new Vector3(screenLineLeft.StartPoint.X, screenLineLeft.StartPoint.Y, 0),
-                TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
-                Colour = colourAt(lineLeft.StartPoint)
-            });
-        }
-
-        private void updateVertexBuffer()
-        {
-            Line line = Segments[0];
-            float theta = line.Theta;
-
-            // Offset by 0.5 pixels inwards to ensure we never sample texels outside the bounds
-            RectangleF texRect = Texture.GetTextureRect(new RectangleF(0.5f, 0.5f, Texture.Width - 1, Texture.Height - 1));
-            addLineCap(line.StartPoint, theta + MathHelper.Pi, MathHelper.Pi, texRect);
-
-            for (int i = 1; i < Segments.Count; ++i)
-            {
-                Line nextLine = Segments[i];
-                float nextTheta = nextLine.Theta;
-                addLineCap(line.EndPoint, theta, nextTheta - theta, texRect);
-
-                line = nextLine;
-                theta = nextTheta;
-            }
-
-            addLineCap(line.EndPoint, theta, MathHelper.Pi, texRect);
-
-            foreach (Line segment in Segments)
-                addLineQuads(segment, texRect);
-        }
-
-        public override void Draw(Action<TexturedVertex2D> vertexAction)
-        {
-            base.Draw(vertexAction);
-
-            if (Texture?.Available != true || Segments.Count == 0)
-                return;
-
-            GLWrapper.PushDepthInfo(DepthInfo.Default);
-
-            IShader shader = needsRoundedShader ? RoundedTextureShader : TextureShader;
-
-            shader.Bind();
-
-            Texture.TextureGL.WrapMode = TextureWrapMode.ClampToEdge;
-            Texture.TextureGL.Bind();
-
-            updateVertexBuffer();
-
-            shader.Unbind();
-
-            GLWrapper.PopDepthInfo();
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            halfCircleBatch.Dispose();
-            quadBatch.Dispose();
-        }
-    }
-}

osu.Framework/Graphics/Lines/Path_DrawNode.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 osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Textures;
+using osuTK.Graphics.ES30;
+using osu.Framework.Graphics.OpenGL;
+using osuTK;
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics.Batches;
+using osu.Framework.Graphics.OpenGL.Vertices;
+using osuTK.Graphics;
+
+namespace osu.Framework.Graphics.Lines
+{
+    public partial class Path
+    {
+        private class PathDrawNode : TexturedShaderDrawNode
+        {
+            public const int MAX_RES = 24;
+
+            protected new Path Source => (Path)base.Source;
+
+            private readonly List<Line> segments = new List<Line>();
+
+            private Texture texture;
+            private Vector2 drawSize;
+            private float radius;
+
+            // We multiply the size param by 3 such that the amount of vertices is a multiple of the amount of vertices
+            // per primitive (triangles in this case). Otherwise overflowing the batch will result in wrong
+            // grouping of vertices into primitives.
+            private readonly LinearBatch<TexturedVertex3D> halfCircleBatch = new LinearBatch<TexturedVertex3D>(MAX_RES * 100 * 3, 10, PrimitiveType.Triangles);
+            private readonly QuadBatch<TexturedVertex3D> quadBatch = new QuadBatch<TexturedVertex3D>(200, 10);
+
+            public PathDrawNode(Path source)
+                : base(source)
+            {
+            }
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                segments.Clear();
+                segments.AddRange(Source.segments);
+
+                texture = Source.Texture;
+                drawSize = Source.DrawSize;
+                radius = Source.PathRadius;
+            }
+
+            private Vector2 pointOnCircle(float angle) => new Vector2((float)Math.Sin(angle), -(float)Math.Cos(angle));
+
+            private Vector2 relativePosition(Vector2 localPos) => Vector2.Divide(localPos, drawSize);
+
+            private Color4 colourAt(Vector2 localPos) => DrawColourInfo.Colour.HasSingleColour
+                ? (Color4)DrawColourInfo.Colour
+                : DrawColourInfo.Colour.Interpolate(relativePosition(localPos)).Linear;
+
+            private void addLineCap(Vector2 origin, float theta, float thetaDiff, RectangleF texRect)
+            {
+                const float step = MathHelper.Pi / MAX_RES;
+
+                float dir = Math.Sign(thetaDiff);
+                thetaDiff = dir * thetaDiff;
+
+                int amountPoints = (int)Math.Ceiling(thetaDiff / step);
+
+                if (dir < 0)
+                    theta += MathHelper.Pi;
+
+                Vector2 current = origin + pointOnCircle(theta) * radius;
+                Color4 currentColour = colourAt(current);
+                current = Vector2Extensions.Transform(current, DrawInfo.Matrix);
+
+                Vector2 screenOrigin = Vector2Extensions.Transform(origin, DrawInfo.Matrix);
+                Color4 originColour = colourAt(origin);
+
+                for (int i = 1; i <= amountPoints; i++)
+                {
+                    // Center point
+                    halfCircleBatch.Add(new TexturedVertex3D
+                    {
+                        Position = new Vector3(screenOrigin.X, screenOrigin.Y, 1),
+                        TexturePosition = new Vector2(texRect.Right, texRect.Centre.Y),
+                        Colour = originColour
+                    });
+
+                    // First outer point
+                    halfCircleBatch.Add(new TexturedVertex3D
+                    {
+                        Position = new Vector3(current.X, current.Y, 0),
+                        TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
+                        Colour = currentColour
+                    });
+
+                    float angularOffset = Math.Min(i * step, thetaDiff);
+                    current = origin + pointOnCircle(theta + dir * angularOffset) * radius;
+                    currentColour = colourAt(current);
+                    current = Vector2Extensions.Transform(current, DrawInfo.Matrix);
+
+                    // Second outer point
+                    halfCircleBatch.Add(new TexturedVertex3D
+                    {
+                        Position = new Vector3(current.X, current.Y, 0),
+                        TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
+                        Colour = currentColour
+                    });
+                }
+            }
+
+            private void addLineQuads(Line line, RectangleF texRect)
+            {
+                Vector2 ortho = line.OrthogonalDirection;
+                Line lineLeft = new Line(line.StartPoint + ortho * radius, line.EndPoint + ortho * radius);
+                Line lineRight = new Line(line.StartPoint - ortho * radius, line.EndPoint - ortho * radius);
+
+                Line screenLineLeft = new Line(Vector2Extensions.Transform(lineLeft.StartPoint, DrawInfo.Matrix), Vector2Extensions.Transform(lineLeft.EndPoint, DrawInfo.Matrix));
+                Line screenLineRight = new Line(Vector2Extensions.Transform(lineRight.StartPoint, DrawInfo.Matrix), Vector2Extensions.Transform(lineRight.EndPoint, DrawInfo.Matrix));
+                Line screenLine = new Line(Vector2Extensions.Transform(line.StartPoint, DrawInfo.Matrix), Vector2Extensions.Transform(line.EndPoint, DrawInfo.Matrix));
+
+                quadBatch.Add(new TexturedVertex3D
+                {
+                    Position = new Vector3(screenLineRight.EndPoint.X, screenLineRight.EndPoint.Y, 0),
+                    TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
+                    Colour = colourAt(lineRight.EndPoint)
+                });
+                quadBatch.Add(new TexturedVertex3D
+                {
+                    Position = new Vector3(screenLineRight.StartPoint.X, screenLineRight.StartPoint.Y, 0),
+                    TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
+                    Colour = colourAt(lineRight.StartPoint)
+                });
+
+                // Each "quad" of the slider is actually rendered as 2 quads, being split in half along the approximating line.
+                // On this line the depth is 1 instead of 0, which is done properly handle self-overlap using the depth buffer.
+                // Thus the middle vertices need to be added twice (once for each quad).
+                Vector3 firstMiddlePoint = new Vector3(screenLine.StartPoint.X, screenLine.StartPoint.Y, 1);
+                Vector3 secondMiddlePoint = new Vector3(screenLine.EndPoint.X, screenLine.EndPoint.Y, 1);
+                Color4 firstMiddleColour = colourAt(line.StartPoint);
+                Color4 secondMiddleColour = colourAt(line.EndPoint);
+
+                for (int i = 0; i < 2; ++i)
+                {
+                    quadBatch.Add(new TexturedVertex3D
+                    {
+                        Position = firstMiddlePoint,
+                        TexturePosition = new Vector2(texRect.Right, texRect.Centre.Y),
+                        Colour = firstMiddleColour
+                    });
+                    quadBatch.Add(new TexturedVertex3D
+                    {
+                        Position = secondMiddlePoint,
+                        TexturePosition = new Vector2(texRect.Right, texRect.Centre.Y),
+                        Colour = secondMiddleColour
+                    });
+                }
+
+                quadBatch.Add(new TexturedVertex3D
+                {
+                    Position = new Vector3(screenLineLeft.EndPoint.X, screenLineLeft.EndPoint.Y, 0),
+                    TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
+                    Colour = colourAt(lineLeft.EndPoint)
+                });
+                quadBatch.Add(new TexturedVertex3D
+                {
+                    Position = new Vector3(screenLineLeft.StartPoint.X, screenLineLeft.StartPoint.Y, 0),
+                    TexturePosition = new Vector2(texRect.Left, texRect.Centre.Y),
+                    Colour = colourAt(lineLeft.StartPoint)
+                });
+            }
+
+            private void updateVertexBuffer()
+            {
+                Line line = segments[0];
+                float theta = line.Theta;
+
+                // Offset by 0.5 pixels inwards to ensure we never sample texels outside the bounds
+                RectangleF texRect = texture.GetTextureRect(new RectangleF(0.5f, 0.5f, texture.Width - 1, texture.Height - 1));
+                addLineCap(line.StartPoint, theta + MathHelper.Pi, MathHelper.Pi, texRect);
+
+                for (int i = 1; i < segments.Count; ++i)
+                {
+                    Line nextLine = segments[i];
+                    float nextTheta = nextLine.Theta;
+                    addLineCap(line.EndPoint, theta, nextTheta - theta, texRect);
+
+                    line = nextLine;
+                    theta = nextTheta;
+                }
+
+                addLineCap(line.EndPoint, theta, MathHelper.Pi, texRect);
+
+                foreach (Line segment in segments)
+                    addLineQuads(segment, texRect);
+            }
+
+            public override void Draw(Action<TexturedVertex2D> vertexAction)
+            {
+                base.Draw(vertexAction);
+
+                if (texture?.Available != true || segments.Count == 0)
+                    return;
+
+                GLWrapper.PushDepthInfo(DepthInfo.Default);
+
+                Shader.Bind();
+
+                texture.TextureGL.WrapMode = TextureWrapMode.ClampToEdge;
+                texture.TextureGL.Bind();
+
+                updateVertexBuffer();
+
+                Shader.Unbind();
+
+                GLWrapper.PopDepthInfo();
+            }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                halfCircleBatch.Dispose();
+                quadBatch.Dispose();
+            }
+        }
+    }
+}

osu.Framework/Graphics/Lines/SmoothPath.cs

···
             textureCache.Validate();
         }
 
+        internal override DrawNode GenerateDrawNodeSubtree(ulong frame, int treeIndex, bool forceNewDrawNode)
+        {
+            validateTexture();
+            return base.GenerateDrawNodeSubtree(frame, treeIndex, forceNewDrawNode);
+        }
+
         /// <summary>
         /// Retrieves the colour from a position in the texture of the <see cref="Path"/>.
         /// </summary>
         /// <param name="position">The position within the texture. 0 indicates the outermost-point of the path, 1 indicates the centre of the path.</param>
         /// <returns></returns>
         protected virtual Color4 ColourAt(float position) => Color4.White;
-
-        protected override void ApplyDrawNode(DrawNode node)
-        {
-            validateTexture();
-
-            base.ApplyDrawNode(node);
-        }
     }
 }

osu.Framework/Graphics/Shapes/Triangle.cs

···
 
         public override bool Contains(Vector2 screenSpacePos) => toTriangle(ScreenSpaceDrawQuad).Contains(screenSpacePos);
 
-        protected override DrawNode CreateDrawNode() => new TriangleDrawNode();
+        protected override DrawNode CreateDrawNode() => new TriangleDrawNode(this);
 
         private class TriangleDrawNode : SpriteDrawNode
         {
+            protected new Triangle Source => (Triangle)base.Source;
+
+            public TriangleDrawNode(Triangle source)
+                : base(source)
+            {
+            }
+
             protected override void Blit(Action<TexturedVertex2D> vertexAction)
             {
                 Texture.DrawTriangle(toTriangle(ScreenSpaceDrawQuad), DrawColourInfo.Colour, null, null,

osu.Framework/Graphics/Sprites/Sprite.cs

···
     /// <summary>
     /// A sprite that displays its texture.
     /// </summary>
-    public class Sprite : Drawable
+    public class Sprite : Drawable, ITexturedShaderDrawable
     {
-        private IShader textureShader;
-        private IShader roundedTextureShader;
+        public IShader TextureShader { get; private set; }
+
+        public IShader RoundedTextureShader { get; private set; }
 
         /// <summary>
         /// True if the texture should be tiled. If you had a 16x16 texture and scaled the sprite to be 64x64 the texture would be repeated in a 4x4 grid along the size of the sprite.
         /// </summary>
-        public bool WrapTexture;
+        public bool WrapTexture { get; set; }
 
         /// <summary>
         /// Maximum value that can be set for <see cref="EdgeSmoothness"/> on either axis.
···
 
         #endregion
 
-        protected override DrawNode CreateDrawNode() => new SpriteDrawNode();
-
-        protected override void ApplyDrawNode(DrawNode node)
-        {
-            SpriteDrawNode n = (SpriteDrawNode)node;
-
-            n.ScreenSpaceDrawQuad = ScreenSpaceDrawQuad;
-            n.DrawRectangle = DrawRectangle;
-            n.Texture = Texture;
-            n.WrapTexture = WrapTexture;
-            n.InflationAmount = inflationAmount;
-            n.TextureShader = textureShader;
-            n.RoundedTextureShader = roundedTextureShader;
-
-            base.ApplyDrawNode(node);
-        }
+        protected override DrawNode CreateDrawNode() => new SpriteDrawNode(this);
 
         [BackgroundDependencyLoader]
         private void load(ShaderManager shaders)
         {
-            textureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE);
-            roundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
+            TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE);
+            RoundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
         }
 
         private Texture texture;
···
             }
         }
 
-        private Vector2 inflationAmount;
+        public Vector2 InflationAmount { get; private set; }
 
         protected override Quad ComputeScreenSpaceDrawQuad()
         {
             if (EdgeSmoothness == Vector2.Zero)
             {
-                inflationAmount = Vector2.Zero;
+                InflationAmount = Vector2.Zero;
                 return base.ComputeScreenSpaceDrawQuad();
             }
 
···
 
             Vector3 scale = DrawInfo.MatrixInverse.ExtractScale();
 
-            inflationAmount = new Vector2(scale.X * EdgeSmoothness.X, scale.Y * EdgeSmoothness.Y);
-            return ToScreenSpace(DrawRectangle.Inflate(inflationAmount));
+            InflationAmount = new Vector2(scale.X * EdgeSmoothness.X, scale.Y * EdgeSmoothness.Y);
+            return ToScreenSpace(DrawRectangle.Inflate(InflationAmount));
         }
 
         public override string ToString()

osu.Framework/Graphics/Sprites/SpriteDrawNode.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;
+using System;
+using osu.Framework.Graphics.OpenGL.Vertices;
 using osu.Framework.Graphics.Primitives;
-using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osuTK.Graphics.ES30;
-using osu.Framework.Graphics.OpenGL;
-using osuTK;
-using System;
-using osu.Framework.Graphics.OpenGL.Vertices;
 
 namespace osu.Framework.Graphics.Sprites
 {
     /// <summary>
     /// Draw node containing all necessary information to draw a <see cref="Sprite"/>.
     /// </summary>
-    public class SpriteDrawNode : DrawNode
+    public class SpriteDrawNode : TexturedShaderDrawNode
     {
-        public Texture Texture;
-        public Quad ScreenSpaceDrawQuad;
-        public RectangleF DrawRectangle;
-        public Vector2 InflationAmount;
-        public bool WrapTexture;
+        protected Texture Texture { get; private set; }
+        protected Quad ScreenSpaceDrawQuad { get; private set; }
+
+        protected RectangleF DrawRectangle { get; private set; }
+        protected Vector2 InflationAmount { get; private set; }
+
+        protected bool WrapTexture { get; private set; }
+
+        protected new Sprite Source => (Sprite)base.Source;
+
+        public SpriteDrawNode(Sprite source)
+            : base(source)
+        {
+        }
 
-        public IShader TextureShader;
-        public IShader RoundedTextureShader;
+        public override void ApplyState()
+        {
+            base.ApplyState();
 
-        private bool needsRoundedShader => GLWrapper.IsMaskingActive || InflationAmount != Vector2.Zero;
+            Texture = Source.Texture;
+            ScreenSpaceDrawQuad = Source.ScreenSpaceDrawQuad;
+            DrawRectangle = Source.DrawRectangle;
+            InflationAmount = Source.InflationAmount;
+            WrapTexture = Source.WrapTexture;
+        }
 
         protected virtual void Blit(Action<TexturedVertex2D> vertexAction)
         {
···
             if (Texture?.Available != true)
                 return;
 
-            IShader shader = needsRoundedShader ? RoundedTextureShader : TextureShader;
-
-            shader.Bind();
-
             Texture.TextureGL.WrapMode = WrapTexture ? TextureWrapMode.Repeat : TextureWrapMode.ClampToEdge;
 
+            Shader.Bind();
+
             Blit(vertexAction);
 
-            shader.Unbind();
+            Shader.Unbind();
         }
+
+        protected override bool RequiresRoundedShader => base.RequiresRoundedShader || InflationAmount != Vector2.Zero;
     }
 }

osu.Framework/Graphics/Sprites/SpriteText.cs

···
     /// <summary>
     /// A container for simple text rendering purposes. If more complex text rendering is required, use <see cref="TextFlowContainer"/> instead.
     /// </summary>
-    public partial class SpriteText : Drawable, IHasLineBaseHeight, IHasText, IHasFilterTerms, IFillFlowContainer, IHasCurrentValue<string>
+    public partial class SpriteText : Drawable, IHasLineBaseHeight, ITexturedShaderDrawable, IHasText, IHasFilterTerms, IFillFlowContainer, IHasCurrentValue<string>
     {
         private const float default_text_size = 20;
         private static readonly Vector2 shadow_offset = new Vector2(0, 0.06f);
···
 
         private float spaceWidth;
 
-        private IShader textureShader;
-        private IShader roundedTextureShader;
+        public IShader TextureShader { get; private set; }
+        public IShader RoundedTextureShader { get; private set; }
 
         public SpriteText()
         {
···
             }, true);
 
             spaceWidth = getTextureForCharacter('.')?.DisplayWidth * 2 ?? 1;
-            textureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE);
-            roundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
+
+            TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE);
+            RoundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
 
             // Pre-cache the characters in the texture store
             foreach (var character in displayedText)
···
 
         #region DrawNode
 
-        protected override DrawNode CreateDrawNode() => new SpriteTextDrawNode();
-
-        protected override void ApplyDrawNode(DrawNode node)
-        {
-            base.ApplyDrawNode(node);
-
-            var n = (SpriteTextDrawNode)node;
-
-            n.Parts.Clear();
-            n.Parts.AddRange(screenSpaceCharacters);
-
-            n.Shadow = Shadow;
-
-            n.TextureShader = textureShader;
-            n.RoundedTextureShader = roundedTextureShader;
-
-            if (Shadow)
-            {
-                n.ShadowColour = ShadowColour;
-                n.ShadowOffset = shadowOffset;
-            }
-        }
+        protected override DrawNode CreateDrawNode() => new SpriteTextDrawNode(this);
 
         #endregion
 

osu.Framework/Graphics/Sprites/SpriteText_DrawNode.cs

···
 using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics.Colour;
-using osu.Framework.Graphics.OpenGL;
 using osu.Framework.Graphics.OpenGL.Vertices;
 using osu.Framework.Graphics.Primitives;
-using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osuTK;
 using osuTK.Graphics;
···
 {
     public partial class SpriteText
     {
-        internal class SpriteTextDrawNode : DrawNode
+        internal class SpriteTextDrawNode : TexturedShaderDrawNode
         {
-            public bool Shadow;
-            public ColourInfo ShadowColour;
-            public Vector2 ShadowOffset;
+            protected new SpriteText Source => (SpriteText)base.Source;
 
-            public IShader TextureShader;
-            public IShader RoundedTextureShader;
+            private bool shadow;
+            private ColourInfo shadowColour;
+            private Vector2 shadowOffset;
 
-            internal readonly List<ScreenSpaceCharacterPart> Parts = new List<ScreenSpaceCharacterPart>();
+            private readonly List<ScreenSpaceCharacterPart> parts = new List<ScreenSpaceCharacterPart>();
 
-            private bool needsRoundedShader => GLWrapper.IsMaskingActive;
+            public SpriteTextDrawNode(SpriteText source)
+                : base(source)
+            {
+            }
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                parts.Clear();
+                parts.AddRange(Source.screenSpaceCharacters);
+                shadow = Source.Shadow;
+
+                if (shadow)
+                {
+                    shadowColour = Source.ShadowColour;
+                    shadowOffset = Source.shadowOffset;
+                }
+            }
 
             public override void Draw(Action<TexturedVertex2D> vertexAction)
             {
                 base.Draw(vertexAction);
 
-                IShader shader = needsRoundedShader ? RoundedTextureShader : TextureShader;
-
-                shader.Bind();
+                Shader.Bind();
 
                 var avgColour = (Color4)DrawColourInfo.Colour.AverageColour;
                 float shadowAlpha = (float)Math.Pow(Math.Max(Math.Max(avgColour.R, avgColour.G), avgColour.B), 2);
 
                 //adjust shadow alpha based on highest component intensity to avoid muddy display of darker text.
                 //squared result for quadratic fall-off seems to give the best result.
-                var shadowColour = DrawColourInfo.Colour;
-                shadowColour.ApplyChild(ShadowColour.MultiplyAlpha(shadowAlpha));
+                var finalShadowColour = DrawColourInfo.Colour;
+                finalShadowColour.ApplyChild(shadowColour.MultiplyAlpha(shadowAlpha));
 
-                for (int i = 0; i < Parts.Count; i++)
+                for (int i = 0; i < parts.Count; i++)
                 {
-                    if (Shadow)
+                    if (shadow)
                     {
-                        var shadowQuad = Parts[i].DrawQuad;
-                        shadowQuad.TopLeft += ShadowOffset;
-                        shadowQuad.TopRight += ShadowOffset;
-                        shadowQuad.BottomLeft += ShadowOffset;
-                        shadowQuad.BottomRight += ShadowOffset;
+                        var shadowQuad = parts[i].DrawQuad;
+                        shadowQuad.TopLeft += shadowOffset;
+                        shadowQuad.TopRight += shadowOffset;
+                        shadowQuad.BottomLeft += shadowOffset;
+                        shadowQuad.BottomRight += shadowOffset;
 
-                        Parts[i].Texture.DrawQuad(shadowQuad, shadowColour, vertexAction: vertexAction);
+                        parts[i].Texture.DrawQuad(shadowQuad, finalShadowColour, vertexAction: vertexAction);
                     }
 
-                    Parts[i].Texture.DrawQuad(Parts[i].DrawQuad, DrawColourInfo.Colour, vertexAction: vertexAction);
+                    parts[i].Texture.DrawQuad(parts[i].DrawQuad, DrawColourInfo.Colour, vertexAction: vertexAction);
                 }
 
-                shader.Unbind();
+                Shader.Unbind();
             }
         }
 

osu.Framework/Graphics/TexturedShaderDrawNode.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 osu.Framework.Graphics.OpenGL;
+using osu.Framework.Graphics.Shaders;
+
+namespace osu.Framework.Graphics
+{
+    public abstract class TexturedShaderDrawNode : DrawNode
+    {
+        protected IShader Shader => RequiresRoundedShader ? roundedTextureShader : textureShader;
+
+        private IShader textureShader;
+        private IShader roundedTextureShader;
+
+        protected new ITexturedShaderDrawable Source => (ITexturedShaderDrawable)base.Source;
+
+        protected TexturedShaderDrawNode(ITexturedShaderDrawable source)
+            : base(source)
+        {
+        }
+
+        public override void ApplyState()
+        {
+            base.ApplyState();
+
+            textureShader = Source.TextureShader;
+            roundedTextureShader = Source.RoundedTextureShader;
+        }
+
+        protected virtual bool RequiresRoundedShader => GLWrapper.IsMaskingActive;
+    }
+}

osu.Framework/Graphics/TransformableExtensions.cs

···
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.MathUtils;
 
 namespace osu.Framework.Graphics

osu.Framework/Graphics/UserInterface/CircularProgress.cs

···
 
 namespace osu.Framework.Graphics.UserInterface
 {
-    public class CircularProgress : Drawable, IHasCurrentValue<double>
+    public class CircularProgress : Drawable, ITexturedShaderDrawable, IHasCurrentValue<double>
     {
         private readonly Bindable<double> current = new Bindable<double>();
 
···
             Current.ValueChanged += newValue => Invalidate(Invalidation.DrawNode);
         }
 
-        private IShader roundedTextureShader;
-        private IShader textureShader;
+        public IShader RoundedTextureShader { get; private set; }
+        public IShader TextureShader { get; private set; }
 
         #region Disposal
 
···
 
         #endregion
 
-        protected override DrawNode CreateDrawNode() => new CircularProgressDrawNode();
-
-        protected override void ApplyDrawNode(DrawNode node)
-        {
-            CircularProgressDrawNode n = (CircularProgressDrawNode)node;
-
-            n.Texture = Texture;
-            n.TextureShader = textureShader;
-            n.RoundedTextureShader = roundedTextureShader;
-            n.DrawSize = DrawSize;
-            n.Angle = (float)Current.Value * MathHelper.TwoPi;
-            n.InnerRadius = innerRadius;
-
-            base.ApplyDrawNode(node);
-        }
+        protected override DrawNode CreateDrawNode() => new CircularProgressDrawNode(this);
 
         public TransformSequence<CircularProgress> FillTo(double newValue, double duration = 0, Easing easing = Easing.None)
             => this.TransformBindableTo(Current, newValue, duration, easing);
···
         [BackgroundDependencyLoader]
         private void load(ShaderManager shaders)
         {
-            roundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
-            textureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE);
+            RoundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
+            TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE);
         }
 
         private Texture texture = Texture.WhitePixel;

osu.Framework/Graphics/UserInterface/CircularProgressDrawNode.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 osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osuTK.Graphics.ES30;
-using osu.Framework.Graphics.OpenGL;
 using osuTK;
 using System;
 using osu.Framework.Graphics.Batches;
···
 
 namespace osu.Framework.Graphics.UserInterface
 {
-    public class CircularProgressDrawNode : DrawNode
+    public class CircularProgressDrawNode : TexturedShaderDrawNode
     {
-        public const int MAXRES = 24;
-        public float Angle;
-        public float InnerRadius = 1;
+        public const int MAX_RES = 24;
 
-        public Vector2 DrawSize;
-        public Texture Texture;
+        protected new CircularProgress Source => (CircularProgress)base.Source;
 
-        public IShader TextureShader;
-        public IShader RoundedTextureShader;
+        private float angle;
+        private float innerRadius = 1;
+
+        private Vector2 drawSize;
+        private Texture texture;
+
+        public CircularProgressDrawNode(CircularProgress source)
+            : base(source)
+        {
+        }
+
+        public override void ApplyState()
+        {
+            base.ApplyState();
+
+            texture = Source.Texture;
+            drawSize = Source.DrawSize;
+            angle = (float)Source.Current.Value * MathHelper.TwoPi;
+            innerRadius = Source.InnerRadius;
+        }
 
         // We add 2 to the size param to account for the first triangle needing every vertex passed, subsequent triangles use the last two vertices of the previous triangle.
-        // MAXRES is being multiplied by 2 to account for each circle part needing 2 triangles
+        // MAX_RES is being multiplied by 2 to account for each circle part needing 2 triangles
         // Otherwise overflowing the batch will result in wrong grouping of vertices into primitives.
-        private readonly LinearBatch<TexturedVertex2D> halfCircleBatch = new LinearBatch<TexturedVertex2D>(MAXRES * 100 * 2 + 2, 10, PrimitiveType.TriangleStrip);
-
-        private bool needsRoundedShader => GLWrapper.IsMaskingActive;
+        private readonly LinearBatch<TexturedVertex2D> halfCircleBatch = new LinearBatch<TexturedVertex2D>(MAX_RES * 100 * 2 + 2, 10, PrimitiveType.TriangleStrip);
 
         private Vector2 pointOnCircle(float angle) => new Vector2((float)Math.Sin(angle), -(float)Math.Cos(angle));
         private float angleToUnitInterval(float angle) => angle / MathHelper.TwoPi + (angle >= 0 ? 0 : 1);
···
         private void updateVertexBuffer()
         {
             const float start_angle = 0;
-            const float step = MathHelper.Pi / MAXRES;
+            const float step = MathHelper.Pi / MAX_RES;
 
-            float dir = Math.Sign(Angle);
+            float dir = Math.Sign(angle);
 
-            int amountPoints = (int)Math.Ceiling(Math.Abs(Angle) / step);
+            int amountPoints = (int)Math.Ceiling(Math.Abs(angle) / step);
 
             Matrix3 transformationMatrix = DrawInfo.Matrix;
-            MatrixExtensions.ScaleFromLeft(ref transformationMatrix, DrawSize);
+            MatrixExtensions.ScaleFromLeft(ref transformationMatrix, drawSize);
 
             Vector2 current = origin + pointOnCircle(start_angle) * 0.5f;
             Color4 currentColour = colourAt(current);
···
             Color4 originColour = colourAt(origin);
 
             // Offset by 0.5 pixels inwards to ensure we never sample texels outside the bounds
-            RectangleF texRect = Texture.GetTextureRect(new RectangleF(0.5f, 0.5f, Texture.Width - 1, Texture.Height - 1));
+            RectangleF texRect = texture.GetTextureRect(new RectangleF(0.5f, 0.5f, texture.Width - 1, texture.Height - 1));
 
             float prevOffset = dir >= 0 ? 0 : 1;
 
             // First center point
             halfCircleBatch.Add(new TexturedVertex2D
             {
-                Position = Vector2.Lerp(current, screenOrigin, InnerRadius),
+                Position = Vector2.Lerp(current, screenOrigin, innerRadius),
                 TexturePosition = new Vector2(dir >= 0 ? texRect.Left : texRect.Right, texRect.Top),
                 Colour = originColour
             });
···
             {
                 // Clamps the angle so we don't overshoot.
                 // dir is used so negative angles result in negative angularOffset.
-                float angularOffset = dir * Math.Min(i * step, dir * Angle);
+                float angularOffset = dir * Math.Min(i * step, dir * angle);
                 float normalisedOffset = angularOffset / MathHelper.TwoPi;
                 if (dir < 0)
                 {
···
                 // current center point
                 halfCircleBatch.Add(new TexturedVertex2D
                 {
-                    Position = Vector2.Lerp(current, screenOrigin, InnerRadius),
+                    Position = Vector2.Lerp(current, screenOrigin, innerRadius),
                     TexturePosition = new Vector2(texRect.Left + (normalisedOffset + prevOffset) / 2 * texRect.Width, texRect.Top),
                     Colour = originColour
                 });
···
         {
             base.Draw(vertexAction);
 
-            if (Texture?.Available != true)
+            if (texture?.Available != true)
                 return;
 
-            IShader shader = needsRoundedShader ? RoundedTextureShader : TextureShader;
-
-            shader.Bind();
+            Shader.Bind();
 
-            Texture.TextureGL.WrapMode = TextureWrapMode.ClampToEdge;
-            Texture.TextureGL.Bind();
+            texture.TextureGL.WrapMode = TextureWrapMode.ClampToEdge;
+            texture.TextureGL.Bind();
 
             updateVertexBuffer();
 
-            shader.Unbind();
+            Shader.Unbind();
         }
 
         protected override void Dispose(bool isDisposing)

osu.Framework/MathUtils/Interpolation.cs

···
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Colour;
-using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Primitives;
 
 namespace osu.Framework.MathUtils

osu.Framework/Platform/GameHost.cs

···
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Drawing;
-using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Runtime;
 using System.Runtime.ExceptionServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
-using NUnit.Framework;
 using osuTK;
 using osuTK.Graphics;
 using osuTK.Graphics.ES30;
···
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
+using osu.Framework.Development;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
···
 
         public void Run(Game game)
         {
+            DebugUtils.HostAssembly = game.GetType().Assembly;
+
             if (ExecutionState != ExecutionState.Idle)
                 throw new InvalidOperationException("A game that has already been run cannot be restarted.");
 
···
 
                 FileSafety.DeleteCleanupDirectory();
 
-                string assemblyPath;
-                var assembly = Assembly.GetEntryAssembly();
-
-                // when running under nunit + netcore, entry assembly becomes nunit itself (testhost, Version=15.0.0.0), which isn't what we want.
-                if (assembly == null || assembly.Location.Contains("testhost"))
-                {
-                    assembly = Assembly.GetExecutingAssembly();
-
-                    // From nuget, the executing assembly will also be wrong
-                    assemblyPath = TestContext.CurrentContext.TestDirectory;
-                }
-                else
-                    assemblyPath = Path.GetDirectoryName(assembly.Location);
+                var assembly = DebugUtils.GetEntryAssembly();
+                string assemblyPath = DebugUtils.GetEntryPath();
 
                 Logger.GameIdentifier = Name;
                 Logger.VersionIdentifier = assembly.GetName().Version.ToString();

osu.Framework/Testing/TestScene.cs

···
 using System.Threading.Tasks;
 using System.Threading;
 using NUnit.Framework.Internal;
+using osu.Framework.Development;
 
 namespace osu.Framework.Testing
 {
···
         private Task runTask;
         private ITestSceneTestRunner runner;
 
-        internal bool IsNUnitRunning;
-
         [OneTimeSetUp]
         public void SetupGameHost()
         {
-            IsNUnitRunning = true;
-
             host = new HeadlessGameHost($"{GetType().Name}-{Guid.NewGuid()}", realtime: false);
             runner = CreateRunner();
 
···
         [SetUp]
         public void SetUpTestForNUnit()
         {
-            if (IsNUnitRunning)
+            if (DebugUtils.IsNUnitRunning)
             {
                 // Since the host is created in OneTimeSetUp, all game threads will have the fixture's execution context
                 // This is undesirable since each test is run using those same threads, so we must make sure the execution context

osu.Framework/Timing/InterpolatingFramedClock.cs

···
 
             if (!allowInterpolation || Math.Abs(FramedSourceClock.CurrentTime - CurrentInterpolatedTime) > AllowableErrorMilliseconds)
             {
-                //if we've exceeded the allowable error, we should use the source clock's time value.
-                CurrentInterpolatedTime = FramedSourceClock.CurrentTime;
+                // if we've exceeded the allowable error, we should use the source clock's time value.
+                // seeking backwards should only be allowed if the source is explicitly doing that.
+                CurrentInterpolatedTime = FramedSourceClock.ElapsedFrameTime < 0 ? FramedSourceClock.CurrentTime : Math.Max(LastInterpolatedTime, FramedSourceClock.CurrentTime);
 
                 // once interpolation fails, we don't want to resume interpolating until the source clock starts to move again.
                 allowInterpolation = false;