Merge branch 'master' into avoid-audio-container-unnecessary-unbind-rebind

osu.Framework.Benchmarks/BenchmarkBindableInstantiation.cs

···
 
 namespace osu.Framework.Benchmarks
 {
+    [MemoryDiagnoser]
     public class BenchmarkBindableInstantiation
     {
-        [Benchmark(Baseline = true)]
-        public Bindable<int> GetBoundCopyOld() => new BindableOld<int>().GetBoundCopy();
+        [Benchmark]
+        public Bindable<int> Instantiate() => new Bindable<int>();
 
         [Benchmark]
         public Bindable<int> GetBoundCopy() => new Bindable<int>().GetBoundCopy();
+
+        [Benchmark(Baseline = true)]
+        public Bindable<int> GetBoundCopyOld() => new BindableOld<int>().GetBoundCopy();
 
         private class BindableOld<T> : Bindable<T>
         {

osu.Framework.Benchmarks/BenchmarkTransform.cs

···
         public Transform CreateSingleBlank() => new TestTransform();
 
         [Benchmark]
+        public void CreateSequenceThenClearAfter()
+        {
+            target.FadeIn(1000, Easing.OutQuint)
+                  .Then().FadeOut(1000)
+                  .Then().FadeOut(1000)
+                  .Then().FadeOut(1000)
+                  .Then().FadeOut(1000)
+                  .Then().FadeOut(1000)
+                  .Then().FadeOut(1000)
+                  .Then().FadeOut(1000)
+                  .Then().FadeOut(1000)
+                  .Then().FadeOut(1000)
+                  .Then().FadeOut(1000);
+
+            target.ClearTransformsAfter(5000);
+        }
+
+        [Benchmark]
+        public void Expiry()
+        {
+            target.FadeIn(1000, Easing.OutQuint)
+                  .ScaleTo(2, 1000, Easing.OutQuint)
+                  .RotateTo(2, 1000, Easing.OutQuint);
+
+            for (int i = 0; i < 1000; i++)
+                target.Expire();
+
+            target.ClearTransforms();
+        }
+
+        [Benchmark]
         public void CreateSequenceWithDefaultEasing()
         {
             target.FadeIn(1000, Easing.OutQuint)

osu.Framework/Audio/AudioAdjustments.cs

···
     /// </summary>
     public class AudioAdjustments : IAdjustableAudioComponent
     {
+        private static readonly AdjustableProperty[] all_adjustments = (AdjustableProperty[])Enum.GetValues(typeof(AdjustableProperty));
+
         /// <summary>
         /// The volume of this component.
         /// </summary>
···
 
         public AudioAdjustments()
         {
-            foreach (AdjustableProperty type in Enum.GetValues(typeof(AdjustableProperty)))
+            foreach (AdjustableProperty type in all_adjustments)
             {
                 var aggregate = getAggregate(type) = new AggregateBindable<double>(getAggregateFunction(type), getProperty(type).GetUnboundCopy());
                 aggregate.AddSource(getProperty(type));
···
 
         public void BindAdjustments(IAggregateAudioAdjustment component)
         {
-            foreach (AdjustableProperty type in Enum.GetValues(typeof(AdjustableProperty)))
+            foreach (AdjustableProperty type in all_adjustments)
                 getAggregate(type).AddSource(component.GetAggregate(type));
         }
 
         public void UnbindAdjustments(IAggregateAudioAdjustment component)
         {
-            foreach (AdjustableProperty type in Enum.GetValues(typeof(AdjustableProperty)))
+            foreach (AdjustableProperty type in all_adjustments)
                 getAggregate(type).RemoveSource(component.GetAggregate(type));
         }
 

osu.Framework/Audio/BassAmplitudeProcessor.cs

···
 
         private float[]? frequencyData;
 
+        private readonly float[] channelLevels = new float[2];
+
         public void Update()
         {
             if (channel.Handle == 0)
···
 
             bool active = channel.Mixer.ChannelIsActive(channel) == PlaybackState.Playing;
 
-            float[] channelLevels = new float[2];
             channel.Mixer.ChannelGetLevel(channel, channelLevels, 1 / 60f, LevelRetrievalFlags.Stereo);
+
             var leftChannel = active ? channelLevels[0] : -1;
             var rightChannel = active ? channelLevels[1] : -1;
 

osu.Framework/Audio/Mixing/Bass/BassAudioMixer.cs

···
 using ManagedBass;
 using ManagedBass.Mix;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Statistics;
 
···
 
             // The channel is always in a playing state unless stopped or stalled as it's a decoding channel. Retrieve the true playing state from the mixer channel.
             if (state == PlaybackState.Playing)
-                state = BassMix.ChannelHasFlag(channel.Handle, BassFlags.MixerChanPause) ? PlaybackState.Paused : state;
+                state = BassMix.ChannelFlags(channel.Handle, BassFlags.Default, BassFlags.Default).HasFlagFast(BassFlags.MixerChanPause) ? PlaybackState.Paused : state;
 
             return state;
         }

osu.Framework/Bindables/Bindable.cs

···
 using System.Linq;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
-using osu.Framework.Caching;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.IO.Serialization;
 using osu.Framework.Lists;
···
             TriggerDefaultChange(previousValue, source ?? this, true, bypassChecks);
         }
 
-        private readonly Cached<WeakReference<Bindable<T>>> weakReferenceCache = new Cached<WeakReference<Bindable<T>>>();
+        private WeakReference<Bindable<T>> weakReferenceInstance;
 
-        private WeakReference<Bindable<T>> weakReference => weakReferenceCache.IsValid ? weakReferenceCache.Value : weakReferenceCache.Value = new WeakReference<Bindable<T>>(this);
+        private WeakReference<Bindable<T>> weakReference => weakReferenceInstance ??= new WeakReference<Bindable<T>>(this);
 
         /// <summary>
         /// Creates a new bindable instance. This is used for deserialization of bindables.

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
             if (!recursive || internalChildren.Count == 0)
                 return base.BeginAbsoluteSequence(newTransformStartTime, false);
 
-            List<IDisposable> disposalActions = new List<IDisposable>(internalChildren.Count + 1);
+            List<AbsoluteSequenceSender> disposalActions = new List<AbsoluteSequenceSender>(internalChildren.Count + 1);
 
             base.CollectAbsoluteSequenceActionsFromSubTree(newTransformStartTime, disposalActions);
 
             foreach (var c in internalChildren)
                 c.CollectAbsoluteSequenceActionsFromSubTree(newTransformStartTime, disposalActions);
 
-            return new ValueInvokeOnDisposal<List<IDisposable>>(disposalActions, actions =>
+            return new ValueInvokeOnDisposal<List<AbsoluteSequenceSender>>(disposalActions, actions =>
             {
                 foreach (var a in actions)
                     a.Dispose();
             });
         }
 
-        internal override void CollectAbsoluteSequenceActionsFromSubTree(double newTransformStartTime, List<IDisposable> actions)
+        internal override void CollectAbsoluteSequenceActionsFromSubTree(double newTransformStartTime, List<AbsoluteSequenceSender> actions)
         {
             base.CollectAbsoluteSequenceActionsFromSubTree(newTransformStartTime, actions);
 

osu.Framework/Graphics/Containers/VisibilityContainer.cs

···
         }
 
         /// <summary>
-        /// Hide this container by setting its visibility to <see cref="Visibility.Visible"/>.
+        /// Show this container by setting its visibility to <see cref="Visibility.Visible"/>.
         /// </summary>
         public override void Show() => State.Value = Visibility.Visible;
 

osu.Framework/Graphics/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.OpenGL;
 using System;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using osu.Framework.Graphics.Batches;
 using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.OpenGL;
 using osu.Framework.Graphics.OpenGL.Buffers;
 using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.OpenGL.Vertices;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Threading;
 using osu.Framework.Utils;
 using osuTK;
 
···
         /// </summary>
         protected IDrawable Source { get; private set; }
 
-        private readonly AtomicCounter referenceCount = new AtomicCounter();
+        private long referenceCount;
 
         /// <summary>
         /// The depth at which drawing should take place.
···
         /// <remarks>
         /// All <see cref="DrawNode"/>s start with a reference count of 1.
         /// </remarks>
-        internal void Reference() => referenceCount.Increment();
+        internal void Reference() => Interlocked.Increment(ref referenceCount);
 
         protected internal bool IsDisposed { get; private set; }
 
         public void Dispose()
         {
-            if (referenceCount.Decrement() != 0)
+            if (Interlocked.Decrement(ref referenceCount) != 0)
                 return;
 
             GLWrapper.ScheduleDisposal(() => Dispose(true));

osu.Framework/Graphics/Drawable.cs

···
                         {
                             a(target);
                         }
-                        catch
+                        catch (Exception e)
                         {
-                            // Execution should continue regardless of whether an unbind failed
+                            Logger.Error(e, $"Failed to unbind a local bindable in {type.ReadableName()}");
                         }
                     }
                 };

osu.Framework/Graphics/Transforms/ITransformSequence.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.
+
+namespace osu.Framework.Graphics.Transforms
+{
+    public interface ITransformSequence
+    {
+        internal void TransformAborted();
+        internal void TransformCompleted();
+    }
+}

osu.Framework/Graphics/Transforms/TargetGroupingTransformTracker.cs

···
         /// <summary>
         /// A list of <see cref="Transform"/>s associated with the <see cref="TargetGrouping"/>.
         /// </summary>
-        public IEnumerable<Transform> Transforms => transforms;
+        public IReadOnlyList<Transform> Transforms => transforms;
 
         /// <summary>
         /// The member this instance is tracking.
···
 
         private readonly Transformable transformable;
 
-        private readonly Queue<Action> removalActions = new Queue<Action>();
+        private readonly Queue<(ITransformSequence sequence, Action<ITransformSequence> action)> removalActions = new Queue<(ITransformSequence, Action<ITransformSequence>)>();
 
         /// <summary>
         /// Used to assign a monotonically increasing ID to <see cref="Transform"/>s as they are added. This member is
···
                             flushAppliedCache = true;
                             i--;
 
-                            if (u.OnAbort != null)
-                                removalActions.Enqueue(u.OnAbort);
+                            if (u.AbortTargetSequence != null)
+                                removalActions.Enqueue((u.AbortTargetSequence, s => s.TransformAborted()));
                         }
                         else
                             u.AppliedToEnd = true;
···
                             transforms.Add(t);
                             flushAppliedCache = true;
                         }
-                        else if (t.OnComplete != null)
-                            removalActions.Enqueue(t.OnComplete);
+                        else if (t.CompletionTargetSequence != null)
+                            removalActions.Enqueue((t.CompletionTargetSequence, s => s.TransformCompleted()));
                     }
                 }
 
···
                 if (t.TargetMember == transform.TargetMember)
                 {
                     transforms.RemoveAt(i--);
-                    if (t.OnAbort != null)
-                        removalActions.Enqueue(t.OnAbort);
+                    if (t.AbortTargetSequence != null)
+                        removalActions.Enqueue((t.AbortTargetSequence, s => s.TransformAborted()));
                 }
             }
 
···
         {
             resetLastAppliedCache();
 
-            Transform[] toAbort;
-
             if (targetMember == null)
             {
-                toAbort = transforms.Where(t => t.StartTime >= time).ToArray();
-                transforms.RemoveAll(t => t.StartTime >= time);
+                for (int i = 0; i < transforms.Count; i++)
+                {
+                    var t = transforms[i];
+
+                    if (t.StartTime >= time)
+                    {
+                        transforms.RemoveAt(i--);
+                        if (t.AbortTargetSequence != null)
+                            removalActions.Enqueue((t.AbortTargetSequence, s => s.TransformAborted()));
+                    }
+                }
             }
             else
             {
-                toAbort = transforms.Where(t => t.TargetMember == targetMember && t.StartTime >= time).ToArray();
-                transforms.RemoveAll(t => t.TargetMember == targetMember && t.StartTime >= time);
+                for (int i = 0; i < transforms.Count; i++)
+                {
+                    var t = transforms[i];
+
+                    if (t.TargetMember == targetMember && t.StartTime >= time)
+                    {
+                        transforms.RemoveAt(i--);
+                        if (t.AbortTargetSequence != null)
+                            removalActions.Enqueue((t.AbortTargetSequence, s => s.TransformAborted()));
+                    }
+                }
             }
 
-            foreach (var t in toAbort)
-                t.OnAbort?.Invoke();
+            invokePendingRemovalActions();
         }
 
         /// <summary>
···
                 }
 
                 t.Apply(t.EndTime);
-                t.OnComplete?.Invoke();
+                t.TriggerComplete();
             }
         }
 
         private void invokePendingRemovalActions()
         {
-            while (removalActions.TryDequeue(out var action))
-                action();
+            while (removalActions.TryDequeue(out var item))
+                item.action(item.sequence);
         }
 
         /// <summary>

osu.Framework/Graphics/Transforms/Transform.cs

···
 
         internal bool HasStartValue;
 
-        public Action OnComplete;
+        internal ITransformSequence CompletionTargetSequence;
 
-        public Action OnAbort;
+        internal ITransformSequence AbortTargetSequence;
 
         public Transform Clone() => (Transform)MemberwiseClone();
 
···
                 return compare;
             }
         }
+
+        internal void TriggerComplete() => CompletionTargetSequence?.TransformCompleted();
+
+        internal void TriggerAbort() => AbortTargetSequence?.TransformAborted();
     }
 
     public abstract class Transform<TValue> : Transform

osu.Framework/Graphics/Transforms/TransformSequence.cs

···
     /// <typeparam name="T">
     /// The type of the <see cref="ITransformable"/> the <see cref="Transform"/>s in this sequence operate upon.
     /// </typeparam>
-    public class TransformSequence<T> where T : class, ITransformable
+    public class TransformSequence<T> : ITransformSequence where T : class, ITransformable
     {
         /// <summary>
         /// A delegate that generates a new <see cref="TransformSequence{T}"/> on a given <paramref name="origin"/>.
···
             // As soon as we have an infinitely looping transform,
             // completion no longer makes sense.
             if (last != null)
-                last.OnComplete = null;
+                last.CompletionTargetSequence = null;
 
             last = null;
             lastEndTime = double.PositiveInfinity;
···
 
             transforms.Add(transform);
 
-            transform.OnComplete = null;
-            transform.OnAbort = onTransformAborted;
+            transform.CompletionTargetSequence = this;
+            transform.AbortTargetSequence = this;
 
             if (transform.IsLooping)
                 onLoopingTransform();
···
             if (last == null || transform.EndTime > lastEndTime)
             {
                 if (last != null)
-                    last.OnComplete = null;
+                    last.CompletionTargetSequence = null;
 
                 last = transform;
-                last.OnComplete = onTransformsComplete;
+                last.CompletionTargetSequence = this;
                 lastEndTime = last.EndTime;
                 hasCompleted = false;
             }
···
             return this;
         }
 
-        private void onTransformAborted()
-        {
-            if (transforms.Count == 0)
-                return;
-
-            // No need for OnAbort events to trigger anymore, since
-            // we are already aware of the abortion.
-            foreach (var t in transforms)
-            {
-                t.OnAbort = null;
-                t.OnComplete = null;
-
-                if (!t.HasStartValue)
-                    t.TargetTransformable.RemoveTransform(t);
-            }
-
-            transforms.Clear();
-            last = null;
-
-            onAbort?.Invoke();
-        }
-
-        private void onTransformsComplete()
-        {
-            hasCompleted = true;
-            onComplete?.Invoke();
-        }
-
         private void subscribeComplete(Action func)
         {
             if (onComplete != null)
···
 
             foreach (var t in transforms)
             {
-                Action tmpOnAbort = t.OnAbort;
-                t.OnAbort = null;
+                var tmpOnAbort = t.AbortTargetSequence;
+                t.AbortTargetSequence = null;
                 t.TargetTransformable.RemoveTransform(t);
-                t.OnAbort = tmpOnAbort;
+                t.AbortTargetSequence = tmpOnAbort;
 
                 // Update start and end times such that no transformations need to be instantly
                 // looped right after they're added. This is required so that transforms can be
···
             if (hasEnd)
                 OnComplete(function);
             OnAbort(function);
+        }
+
+        void ITransformSequence.TransformAborted()
+        {
+            if (transforms.Count == 0)
+                return;
+
+            // No need for OnAbort events to trigger anymore, since
+            // we are already aware of the abortion.
+            foreach (var t in transforms)
+            {
+                t.AbortTargetSequence = null;
+                t.CompletionTargetSequence = null;
+
+                if (!t.HasStartValue)
+                    t.TargetTransformable.RemoveTransform(t);
+            }
+
+            transforms.Clear();
+            last = null;
+
+            onAbort?.Invoke();
+        }
+
+        void ITransformSequence.TransformCompleted()
+        {
+            hasCompleted = true;
+            onComplete?.Invoke();
         }
     }
 }

osu.Framework/Graphics/Transforms/Transformable.cs

···
                 //expiry should happen either at the end of the last transform or using the current sequence delay (whichever is highest).
                 double max = TransformStartTime;
 
-                foreach (Transform t in Transforms)
+                foreach (var tracker in targetGroupingTrackers)
                 {
-                    if (t.EndTime > max)
-                        max = t.EndTime + 1; //adding 1ms here ensures we can expire on the current frame without issue.
+                    for (int i = 0; i < tracker.Transforms.Count; i++)
+                    {
+                        var t = tracker.Transforms[i];
+                        if (t.EndTime > max)
+                            max = t.EndTime + 1; //adding 1ms here ensures we can expire on the current frame without issue.
+                    }
                 }
 
                 return max;
···
 
             getTrackerForGrouping(toRemove.TargetGrouping, false)?.RemoveTransform(toRemove);
 
-            toRemove.OnAbort?.Invoke();
+            toRemove.TriggerAbort();
         }
 
         /// <summary>
···
             return createAbsoluteSequenceAction(newTransformStartTime);
         }
 
-        internal virtual void CollectAbsoluteSequenceActionsFromSubTree(double newTransformStartTime, List<IDisposable> actions)
+        internal virtual void CollectAbsoluteSequenceActionsFromSubTree(double newTransformStartTime, List<AbsoluteSequenceSender> actions)
         {
             actions.Add(createAbsoluteSequenceAction(newTransformStartTime));
         }
 
-        private IDisposable createAbsoluteSequenceAction(double newTransformStartTime)
+        private AbsoluteSequenceSender createAbsoluteSequenceAction(double newTransformStartTime)
         {
             double oldTransformDelay = TransformDelay;
             double newTransformDelay = TransformDelay = newTransformStartTime - (Clock?.CurrentTime ?? 0);
 
-            return new ValueInvokeOnDisposal<AbsoluteSequenceSender>(new AbsoluteSequenceSender(this, oldTransformDelay, newTransformDelay), sender =>
-            {
-                if (!Precision.AlmostEquals(sender.NewTransformDelay, sender.Transformable.TransformDelay))
-                {
-                    throw new InvalidOperationException(
-                        $"{nameof(sender.Transformable.TransformStartTime)} at the end of absolute sequence is not the same as at the beginning, but should be. " +
-                        $"(begin={sender.NewTransformDelay} end={sender.Transformable.TransformDelay})");
-                }
-
-                sender.Transformable.TransformDelay = sender.OldTransformDelay;
-            });
+            return new AbsoluteSequenceSender(this, oldTransformDelay, newTransformDelay);
         }
 
         /// An ad-hoc struct used as a closure environment in <see cref="BeginAbsoluteSequence" />.
-        private readonly struct AbsoluteSequenceSender
+        internal readonly struct AbsoluteSequenceSender : IDisposable
         {
-            public readonly Transformable Transformable;
+            public readonly Transformable Sender;
+
             public readonly double OldTransformDelay;
             public readonly double NewTransformDelay;
 
-            public AbsoluteSequenceSender(Transformable transformable, double oldTransformDelay, double newTransformDelay)
+            public AbsoluteSequenceSender(Transformable sender, double oldTransformDelay, double newTransformDelay)
             {
-                Transformable = transformable;
                 OldTransformDelay = oldTransformDelay;
                 NewTransformDelay = newTransformDelay;
+
+                Sender = sender;
+            }
+
+            public void Dispose()
+            {
+                if (!Precision.AlmostEquals(NewTransformDelay, Sender.TransformDelay))
+                {
+                    throw new InvalidOperationException(
+                        $"{nameof(Sender.TransformStartTime)} at the end of absolute sequence is not the same as at the beginning, but should be. " +
+                        $"(begin={NewTransformDelay} end={Sender.TransformDelay})");
+                }
+
+                Sender.TransformDelay = OldTransformDelay;
             }
         }
 
···
                 }
 
                 transform.Apply(transform.EndTime);
-                transform.OnComplete?.Invoke();
+                transform.TriggerComplete();
+
                 return;
             }
 

osu.Framework/Lists/SortedList.cs

···
 
         public virtual void RemoveAt(int index) => list.RemoveAt(index);
 
-        public int RemoveAll(Predicate<T> match)
-        {
-            List<T> found = (List<T>)FindAll(match);
-
-            foreach (var i in found)
-                Remove(i);
-
-            return found.Count;
-        }
+        public int RemoveAll(Predicate<T> match) => list.RemoveAll(match);
 
         public virtual void Clear() => list.Clear();
 

osu.Framework/Threading/AtomicCounter.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.Threading;
-
-namespace osu.Framework.Threading
-{
-    public class AtomicCounter
-    {
-        private long count;
-
-        public long Increment() => Interlocked.Increment(ref count);
-
-        public long Decrement() => Interlocked.Decrement(ref count);
-
-        public long Add(long value) => Interlocked.Add(ref count, value);
-
-        public long Reset() => Interlocked.Exchange(ref count, 0);
-
-        public long Value
-        {
-            set => Interlocked.Exchange(ref count, value);
-            get => Interlocked.Read(ref count);
-        }
-    }
-}