From 5765007ecdbd3c6ec8b9dac281076bd90e40f313 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Thu, 20 May 2021 01:03:41 +0200
Subject: [PATCH 1/9] Avoid closures and extra allocations caused by transition
 observables.

---
 .../AnimatorDrivenTransition.cs               | 15 +++
 .../AnimatorTransitionObservable.cs           | 24 +++++
 .../{Transition`1.cs => Transition.cs}        |  6 +-
 src/Avalonia.Animation/TransitionInstance.cs  | 23 +++--
 .../TransitionObservableBase.cs               | 45 +++++++++
 .../Transitions/DoubleTransition.cs           |  7 +-
 .../TransformOperationsTransition.cs          | 18 ++--
 .../Animations/TransitionBenchmark.cs         | 92 +++++++++++++++++++
 8 files changed, 208 insertions(+), 22 deletions(-)
 create mode 100644 src/Avalonia.Animation/AnimatorDrivenTransition.cs
 create mode 100644 src/Avalonia.Animation/AnimatorTransitionObservable.cs
 rename src/Avalonia.Animation/{Transition`1.cs => Transition.cs} (96%)
 create mode 100644 src/Avalonia.Animation/TransitionObservableBase.cs
 create mode 100644 tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs

diff --git a/src/Avalonia.Animation/AnimatorDrivenTransition.cs b/src/Avalonia.Animation/AnimatorDrivenTransition.cs
new file mode 100644
index 0000000000..eb4d6f978d
--- /dev/null
+++ b/src/Avalonia.Animation/AnimatorDrivenTransition.cs
@@ -0,0 +1,15 @@
+using System;
+using Avalonia.Animation.Animators;
+
+namespace Avalonia.Animation
+{
+    public class AnimatorDrivenTransition<T, TAnimator> : Transition<T> where TAnimator : Animator<T>, new()
+    {
+        private static readonly TAnimator s_animator = new TAnimator();
+
+        public override IObservable<T> DoTransition(IObservable<double> progress, T oldValue, T newValue)
+        {
+            return new AnimatorTransitionObservable<T, TAnimator>(s_animator, progress, oldValue, newValue);
+        }
+    }
+}
diff --git a/src/Avalonia.Animation/AnimatorTransitionObservable.cs b/src/Avalonia.Animation/AnimatorTransitionObservable.cs
new file mode 100644
index 0000000000..4f888e1f15
--- /dev/null
+++ b/src/Avalonia.Animation/AnimatorTransitionObservable.cs
@@ -0,0 +1,24 @@
+using System;
+using Avalonia.Animation.Animators;
+
+namespace Avalonia.Animation
+{
+    public class AnimatorTransitionObservable<T, TAnimator> : TransitionObservableBase<T> where TAnimator : Animator<T>
+    {
+        private readonly TAnimator _animator;
+        private readonly T _oldValue;
+        private readonly T _newValue;
+
+        public AnimatorTransitionObservable(TAnimator animator, IObservable<double> progress, T oldValue, T newValue) : base(progress)
+        {
+            _animator = animator;
+            _oldValue = oldValue;
+            _newValue = newValue;
+        }
+
+        protected override T ProduceValue(double progress)
+        {
+            return _animator.Interpolate(progress, _oldValue, _newValue);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Animation/Transition`1.cs b/src/Avalonia.Animation/Transition.cs
similarity index 96%
rename from src/Avalonia.Animation/Transition`1.cs
rename to src/Avalonia.Animation/Transition.cs
index 4542a137e5..4115c95c0f 100644
--- a/src/Avalonia.Animation/Transition`1.cs
+++ b/src/Avalonia.Animation/Transition.cs
@@ -1,7 +1,5 @@
-using System;
-using System.Reactive.Linq;
+using System;
 using Avalonia.Animation.Easings;
-using Avalonia.Animation.Utils;
 
 namespace Avalonia.Animation
 {
@@ -56,4 +54,4 @@ namespace Avalonia.Animation
             return control.Bind<T>((AvaloniaProperty<T>)Property, transition, Data.BindingPriority.Animation);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Avalonia.Animation/TransitionInstance.cs b/src/Avalonia.Animation/TransitionInstance.cs
index 5184341324..58dd71e8a5 100644
--- a/src/Avalonia.Animation/TransitionInstance.cs
+++ b/src/Avalonia.Animation/TransitionInstance.cs
@@ -1,8 +1,4 @@
-using Avalonia.Metadata;
 using System;
-using System.Reactive.Linq;
-using Avalonia.Animation.Easings;
-using Avalonia.Animation.Utils;
 using Avalonia.Reactive;
 using Avalonia.Utilities;
 
@@ -11,7 +7,7 @@ namespace Avalonia.Animation
     /// <summary>
     /// Handles the timing and lifetime of a <see cref="Transition{T}"/>.
     /// </summary>
-    internal class TransitionInstance : SingleSubscriberObservableBase<double>
+    internal class TransitionInstance : SingleSubscriberObservableBase<double>, IObserver<TimeSpan>
     {
         private IDisposable _timerSubscription;
         private TimeSpan _delay;
@@ -76,8 +72,23 @@ namespace Avalonia.Animation
         protected override void Subscribed()
         {
             _clock = new Clock(_baseClock);
-            _timerSubscription = _clock.Subscribe(TimerTick);
+            _timerSubscription = _clock.Subscribe(this);
             PublishNext(0.0d);
         }
+
+        void IObserver<TimeSpan>.OnCompleted()
+        {
+            PublishCompleted();
+        }
+
+        void IObserver<TimeSpan>.OnError(Exception error)
+        {
+            PublishError(error);
+        }
+
+        void IObserver<TimeSpan>.OnNext(TimeSpan value)
+        {
+            TimerTick(value);
+        }
     }
 }
diff --git a/src/Avalonia.Animation/TransitionObservableBase.cs b/src/Avalonia.Animation/TransitionObservableBase.cs
new file mode 100644
index 0000000000..e18b6859f5
--- /dev/null
+++ b/src/Avalonia.Animation/TransitionObservableBase.cs
@@ -0,0 +1,45 @@
+using System;
+using Avalonia.Reactive;
+
+#nullable enable
+
+namespace Avalonia.Animation
+{
+    public abstract class TransitionObservableBase<T> : SingleSubscriberObservableBase<T>, IObserver<double>
+    {
+        private readonly IObservable<double> _progress;
+        private IDisposable? _progressSubscription;
+
+        protected TransitionObservableBase(IObservable<double> progress)
+        {
+            _progress = progress;
+        }
+
+        protected override void Unsubscribed()
+        {
+            _progressSubscription?.Dispose();
+        }
+
+        protected override void Subscribed()
+        {
+            _progressSubscription = _progress.Subscribe(this);
+        }
+
+        protected abstract T ProduceValue(double progress);
+
+        void IObserver<double>.OnCompleted()
+        {
+            PublishCompleted();
+        }
+
+        void IObserver<double>.OnError(Exception error)
+        {
+            PublishError(error);
+        }
+
+        void IObserver<double>.OnNext(double value)
+        {
+            PublishNext(ProduceValue(value));
+        }
+    }
+}
diff --git a/src/Avalonia.Animation/Transitions/DoubleTransition.cs b/src/Avalonia.Animation/Transitions/DoubleTransition.cs
index d5bb1aac20..28f630eb98 100644
--- a/src/Avalonia.Animation/Transitions/DoubleTransition.cs
+++ b/src/Avalonia.Animation/Transitions/DoubleTransition.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Reactive.Linq;
-
 using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
@@ -8,7 +7,11 @@ namespace Avalonia.Animation
     /// <summary>
     /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="double"/> types.
     /// </summary>  
-    public class DoubleTransition : Transition<double>
+    public class DoubleTransition : AnimatorDrivenTransition<double, DoubleAnimator>
+    {
+    }
+
+    public class DoubleTransitionOld : Transition<double>
     {
         private static readonly DoubleAnimator s_animator = new DoubleAnimator();
 
diff --git a/src/Avalonia.Visuals/Animation/Transitions/TransformOperationsTransition.cs b/src/Avalonia.Visuals/Animation/Transitions/TransformOperationsTransition.cs
index 104acb71ad..ca1528a561 100644
--- a/src/Avalonia.Visuals/Animation/Transitions/TransformOperationsTransition.cs
+++ b/src/Avalonia.Visuals/Animation/Transitions/TransformOperationsTransition.cs
@@ -1,28 +1,26 @@
 using System;
-using System.Reactive.Linq;
 using Avalonia.Animation.Animators;
 using Avalonia.Media;
+using Avalonia.Media.Transformation;
+
+#nullable enable
 
 namespace Avalonia.Animation
 {
     public class TransformOperationsTransition : Transition<ITransform>
     {
-        private static readonly TransformOperationsAnimator _operationsAnimator =  new TransformOperationsAnimator();
+        private static readonly TransformOperationsAnimator s_operationsAnimator = new TransformOperationsAnimator();
 
-        public override IObservable<ITransform> DoTransition(IObservable<double> progress,
+        public override IObservable<ITransform> DoTransition(
+            IObservable<double> progress,
             ITransform oldValue,
             ITransform newValue)
         {
             var oldTransform = TransformOperationsAnimator.EnsureOperations(oldValue);
             var newTransform = TransformOperationsAnimator.EnsureOperations(newValue);
 
-            return progress
-                .Select(p =>
-                {
-                    var f = Easing.Ease(p);
-
-                    return _operationsAnimator.Interpolate(f, oldTransform, newTransform);
-                });
+            return new AnimatorTransitionObservable<TransformOperations, TransformOperationsAnimator>(
+                s_operationsAnimator, progress, oldTransform, newTransform);
         }
     }
 }
diff --git a/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs b/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs
new file mode 100644
index 0000000000..16aad0c21b
--- /dev/null
+++ b/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs
@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reactive.Subjects;
+using System.Runtime.CompilerServices;
+using Avalonia.Animation;
+using Avalonia.Layout;
+using BenchmarkDotNet.Attributes;
+
+namespace Avalonia.Benchmarks.Animations
+{
+    [MemoryDiagnoser]
+    public class TransitionBenchmark
+    {
+        private readonly DoubleTransition _transition;
+        private readonly DoubleTransitionOld _oldTransition;
+        private readonly int _frameCount;
+        private readonly Subject<double> _timeProducer;
+        private readonly List<double> _producedValues;
+
+        public TransitionBenchmark()
+        {
+            _frameCount = 100;
+
+            _oldTransition = new DoubleTransitionOld
+            {
+                Duration = TimeSpan.FromMilliseconds(_frameCount), Property = Layoutable.WidthProperty
+            };
+
+            _transition = new DoubleTransition
+            {
+                Duration = TimeSpan.FromMilliseconds(_frameCount), Property = Layoutable.WidthProperty
+            };
+
+            _timeProducer = new Subject<double>();
+            _producedValues = new List<double>(_frameCount);
+        }
+
+        [Benchmark(Baseline = true)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public void OldTransition()
+        {
+            TransitionCommon(_oldTransition);
+        }
+
+        [Benchmark]
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public void NewTransition()
+        {
+            TransitionCommon(_transition);
+        }
+
+        private void TransitionCommon(Transition<double> transition)
+        {
+            var transitionObs = transition.DoTransition(_timeProducer, 0, 1);
+
+            _producedValues.Clear();
+
+            using var transitionSub = transitionObs.Subscribe(new AddValueObserver(_producedValues));
+
+            for (int i = 0; i < _frameCount; i++)
+            {
+                _timeProducer.OnNext(TimeSpan.FromMilliseconds(i).TotalSeconds);
+            }
+
+            Debug.Assert(_producedValues.Count == _frameCount);
+        }
+
+        private class AddValueObserver : IObserver<double>
+        {
+            private readonly List<double> _values;
+
+            public AddValueObserver(List<double> values)
+            {
+                _values = values;
+            }
+
+            public void OnCompleted()
+            {
+            }
+
+            public void OnError(Exception error)
+            {
+            }
+
+            public void OnNext(double value)
+            {
+                _values.Add(value);
+            }
+        }
+    }
+}

From 9bf33631ab267e6cd8a42439bc4a0cdec6655fa6 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Thu, 20 May 2021 01:31:27 +0200
Subject: [PATCH 2/9] Make base transition abstract.

---
 src/Avalonia.Animation/AnimatorDrivenTransition.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Animation/AnimatorDrivenTransition.cs b/src/Avalonia.Animation/AnimatorDrivenTransition.cs
index eb4d6f978d..13139f8e8d 100644
--- a/src/Avalonia.Animation/AnimatorDrivenTransition.cs
+++ b/src/Avalonia.Animation/AnimatorDrivenTransition.cs
@@ -3,7 +3,7 @@ using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
 {
-    public class AnimatorDrivenTransition<T, TAnimator> : Transition<T> where TAnimator : Animator<T>, new()
+    public abstract class AnimatorDrivenTransition<T, TAnimator> : Transition<T> where TAnimator : Animator<T>, new()
     {
         private static readonly TAnimator s_animator = new TAnimator();
 

From 82ca716cca8cd879becc13bd5351d296ef67693e Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Thu, 20 May 2021 01:32:23 +0200
Subject: [PATCH 3/9] Remove ref counting from ClockBase.

---
 src/Avalonia.Animation/ClockBase.cs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/Avalonia.Animation/ClockBase.cs b/src/Avalonia.Animation/ClockBase.cs
index a2b29e728e..9fa6a85a6c 100644
--- a/src/Avalonia.Animation/ClockBase.cs
+++ b/src/Avalonia.Animation/ClockBase.cs
@@ -8,9 +8,7 @@ namespace Avalonia.Animation
 {
     public class ClockBase : IClock
     {
-        private ClockObservable _observable;
-
-        private IObservable<TimeSpan> _connectedObservable;
+        private readonly ClockObservable _observable;
 
         private TimeSpan? _previousTime;
         private TimeSpan _internalTime;
@@ -18,7 +16,6 @@ namespace Avalonia.Animation
         protected ClockBase()
         {
             _observable = new ClockObservable();
-            _connectedObservable = _observable.Publish().RefCount();
         }
 
         protected bool HasSubscriptions => _observable.HasSubscriptions;
@@ -58,7 +55,7 @@ namespace Avalonia.Animation
 
         public IDisposable Subscribe(IObserver<TimeSpan> observer)
         {
-            return _connectedObservable.Subscribe(observer);
+            return _observable.Subscribe(observer);
         }
 
         private class ClockObservable : LightweightObservableBase<TimeSpan>

From 54090bc1f7263da7c4674616be1c342fa8e8aac7 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Thu, 20 May 2021 01:47:37 +0200
Subject: [PATCH 4/9] Apply easing.

---
 src/Avalonia.Animation/AnimatorDrivenTransition.cs       | 2 +-
 src/Avalonia.Animation/AnimatorTransitionObservable.cs   | 9 +++++++--
 .../Transitions/TransformOperationsTransition.cs         | 2 +-
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Animation/AnimatorDrivenTransition.cs b/src/Avalonia.Animation/AnimatorDrivenTransition.cs
index 13139f8e8d..3f6ac47556 100644
--- a/src/Avalonia.Animation/AnimatorDrivenTransition.cs
+++ b/src/Avalonia.Animation/AnimatorDrivenTransition.cs
@@ -9,7 +9,7 @@ namespace Avalonia.Animation
 
         public override IObservable<T> DoTransition(IObservable<double> progress, T oldValue, T newValue)
         {
-            return new AnimatorTransitionObservable<T, TAnimator>(s_animator, progress, oldValue, newValue);
+            return new AnimatorTransitionObservable<T, TAnimator>(s_animator, progress, Easing, oldValue, newValue);
         }
     }
 }
diff --git a/src/Avalonia.Animation/AnimatorTransitionObservable.cs b/src/Avalonia.Animation/AnimatorTransitionObservable.cs
index 4f888e1f15..10c19bb62b 100644
--- a/src/Avalonia.Animation/AnimatorTransitionObservable.cs
+++ b/src/Avalonia.Animation/AnimatorTransitionObservable.cs
@@ -1,24 +1,29 @@
 using System;
 using Avalonia.Animation.Animators;
+using Avalonia.Animation.Easings;
 
 namespace Avalonia.Animation
 {
     public class AnimatorTransitionObservable<T, TAnimator> : TransitionObservableBase<T> where TAnimator : Animator<T>
     {
         private readonly TAnimator _animator;
+        private readonly Easing _easing;
         private readonly T _oldValue;
         private readonly T _newValue;
 
-        public AnimatorTransitionObservable(TAnimator animator, IObservable<double> progress, T oldValue, T newValue) : base(progress)
+        public AnimatorTransitionObservable(TAnimator animator, IObservable<double> progress, Easing easing, T oldValue, T newValue) : base(progress)
         {
             _animator = animator;
+            _easing = easing;
             _oldValue = oldValue;
             _newValue = newValue;
         }
 
         protected override T ProduceValue(double progress)
         {
+            progress = _easing.Ease(progress);
+
             return _animator.Interpolate(progress, _oldValue, _newValue);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Visuals/Animation/Transitions/TransformOperationsTransition.cs b/src/Avalonia.Visuals/Animation/Transitions/TransformOperationsTransition.cs
index ca1528a561..73fc23ad99 100644
--- a/src/Avalonia.Visuals/Animation/Transitions/TransformOperationsTransition.cs
+++ b/src/Avalonia.Visuals/Animation/Transitions/TransformOperationsTransition.cs
@@ -20,7 +20,7 @@ namespace Avalonia.Animation
             var newTransform = TransformOperationsAnimator.EnsureOperations(newValue);
 
             return new AnimatorTransitionObservable<TransformOperations, TransformOperationsAnimator>(
-                s_operationsAnimator, progress, oldTransform, newTransform);
+                s_operationsAnimator, progress, Easing, oldTransform, newTransform);
         }
     }
 }

From 60ad7eae12fb366475fab8eb615432af3ea05093 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Thu, 20 May 2021 20:35:07 +0200
Subject: [PATCH 5/9] More cleanup.

---
 src/Avalonia.Animation/Clock.cs               |  5 ++--
 .../TransitionObservableBase.cs               | 24 +++++++++----------
 2 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/Avalonia.Animation/Clock.cs b/src/Avalonia.Animation/Clock.cs
index bea6c75982..6c7ae8349a 100644
--- a/src/Avalonia.Animation/Clock.cs
+++ b/src/Avalonia.Animation/Clock.cs
@@ -10,10 +10,9 @@ namespace Avalonia.Animation
     {
         public static IClock GlobalClock => AvaloniaLocator.Current.GetService<IGlobalClock>();
 
-        private IDisposable _parentSubscription;
+        private readonly IDisposable _parentSubscription;
 
-        public Clock()
-            :this(GlobalClock)
+        public Clock() : this(GlobalClock)
         {
         }
         
diff --git a/src/Avalonia.Animation/TransitionObservableBase.cs b/src/Avalonia.Animation/TransitionObservableBase.cs
index e18b6859f5..9f4fb8093c 100644
--- a/src/Avalonia.Animation/TransitionObservableBase.cs
+++ b/src/Avalonia.Animation/TransitionObservableBase.cs
@@ -15,18 +15,6 @@ namespace Avalonia.Animation
             _progress = progress;
         }
 
-        protected override void Unsubscribed()
-        {
-            _progressSubscription?.Dispose();
-        }
-
-        protected override void Subscribed()
-        {
-            _progressSubscription = _progress.Subscribe(this);
-        }
-
-        protected abstract T ProduceValue(double progress);
-
         void IObserver<double>.OnCompleted()
         {
             PublishCompleted();
@@ -41,5 +29,17 @@ namespace Avalonia.Animation
         {
             PublishNext(ProduceValue(value));
         }
+
+        protected override void Unsubscribed()
+        {
+            _progressSubscription?.Dispose();
+        }
+
+        protected override void Subscribed()
+        {
+            _progressSubscription = _progress.Subscribe(this);
+        }
+
+        protected abstract T ProduceValue(double progress);
     }
 }

From 21b7b88b0f53afb715f76adcb1332a9a6863e874 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Mon, 24 May 2021 01:52:19 +0200
Subject: [PATCH 6/9] Cleanup and refactor leftover transition types.

---
 .../AnimatorDrivenTransition.cs               |  5 +++
 .../AnimatorTransitionObservable.cs           |  9 +++--
 src/Avalonia.Animation/Clock.cs               |  4 --
 src/Avalonia.Animation/ClockBase.cs           |  5 +--
 src/Avalonia.Animation/TransitionInstance.cs  | 37 +++++++++++++++++-
 .../TransitionObservableBase.cs               | 39 ++++++++++++-------
 .../Transitions/DoubleTransition.cs           | 14 -------
 .../Transitions/FloatTransition.cs            | 13 +------
 .../Transitions/IntegerTransition.cs          | 13 +------
 .../Transitions/BoxShadowsTransition.cs       | 13 +------
 .../Animation/Transitions/ColorTransition.cs  | 12 ++++++
 .../Transitions/CornerRadiusTransition.cs     | 13 +------
 .../Animation/Transitions/PointTransition.cs  | 13 +------
 .../Animation/Transitions/SizeTransition.cs   | 13 +------
 .../Transitions/ThicknessTransition.cs        | 13 +------
 .../Animation/Transitions/VectorTransition.cs | 13 +------
 .../Animations/TransitionBenchmark.cs         | 37 +++++++++++++-----
 17 files changed, 120 insertions(+), 146 deletions(-)
 create mode 100644 src/Avalonia.Visuals/Animation/Transitions/ColorTransition.cs

diff --git a/src/Avalonia.Animation/AnimatorDrivenTransition.cs b/src/Avalonia.Animation/AnimatorDrivenTransition.cs
index 3f6ac47556..88c8ec5ec1 100644
--- a/src/Avalonia.Animation/AnimatorDrivenTransition.cs
+++ b/src/Avalonia.Animation/AnimatorDrivenTransition.cs
@@ -3,6 +3,11 @@ using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
 {
+    /// <summary>
+    /// <see cref="Transition{T}"/> using an <see cref="Animator{T}"/> to transition between values.
+    /// </summary>
+    /// <typeparam name="T">Type of the transitioned value.</typeparam>
+    /// <typeparam name="TAnimator">Type of the animator.</typeparam>
     public abstract class AnimatorDrivenTransition<T, TAnimator> : Transition<T> where TAnimator : Animator<T>, new()
     {
         private static readonly TAnimator s_animator = new TAnimator();
diff --git a/src/Avalonia.Animation/AnimatorTransitionObservable.cs b/src/Avalonia.Animation/AnimatorTransitionObservable.cs
index 10c19bb62b..3cc185179b 100644
--- a/src/Avalonia.Animation/AnimatorTransitionObservable.cs
+++ b/src/Avalonia.Animation/AnimatorTransitionObservable.cs
@@ -4,6 +4,11 @@ using Avalonia.Animation.Easings;
 
 namespace Avalonia.Animation
 {
+    /// <summary>
+    /// Transition observable based on an <see cref="Animator{T}"/> producing a value.
+    /// </summary>
+    /// <typeparam name="T">Type of the transitioned value.</typeparam>
+    /// <typeparam name="TAnimator">Type of the animator.</typeparam>
     public class AnimatorTransitionObservable<T, TAnimator> : TransitionObservableBase<T> where TAnimator : Animator<T>
     {
         private readonly TAnimator _animator;
@@ -11,7 +16,7 @@ namespace Avalonia.Animation
         private readonly T _oldValue;
         private readonly T _newValue;
 
-        public AnimatorTransitionObservable(TAnimator animator, IObservable<double> progress, Easing easing, T oldValue, T newValue) : base(progress)
+        public AnimatorTransitionObservable(TAnimator animator, IObservable<double> progress, Easing easing, T oldValue, T newValue) : base(progress, easing)
         {
             _animator = animator;
             _easing = easing;
@@ -21,8 +26,6 @@ namespace Avalonia.Animation
 
         protected override T ProduceValue(double progress)
         {
-            progress = _easing.Ease(progress);
-
             return _animator.Interpolate(progress, _oldValue, _newValue);
         }
     }
diff --git a/src/Avalonia.Animation/Clock.cs b/src/Avalonia.Animation/Clock.cs
index 6c7ae8349a..5c2b7ce0dd 100644
--- a/src/Avalonia.Animation/Clock.cs
+++ b/src/Avalonia.Animation/Clock.cs
@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Reactive.Linq;
-using System.Text;
-using Avalonia.Reactive;
 
 namespace Avalonia.Animation
 {
diff --git a/src/Avalonia.Animation/ClockBase.cs b/src/Avalonia.Animation/ClockBase.cs
index 9fa6a85a6c..c6e5a363be 100644
--- a/src/Avalonia.Animation/ClockBase.cs
+++ b/src/Avalonia.Animation/ClockBase.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Reactive.Linq;
-using System.Text;
 using Avalonia.Reactive;
 
 namespace Avalonia.Animation
@@ -58,7 +55,7 @@ namespace Avalonia.Animation
             return _observable.Subscribe(observer);
         }
 
-        private class ClockObservable : LightweightObservableBase<TimeSpan>
+        private sealed class ClockObservable : LightweightObservableBase<TimeSpan>
         {
             public bool HasSubscriptions { get; private set; }
             public void Pulse(TimeSpan time) => PublishNext(time);
diff --git a/src/Avalonia.Animation/TransitionInstance.cs b/src/Avalonia.Animation/TransitionInstance.cs
index 58dd71e8a5..b522d1961e 100644
--- a/src/Avalonia.Animation/TransitionInstance.cs
+++ b/src/Avalonia.Animation/TransitionInstance.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.ExceptionServices;
 using Avalonia.Reactive;
 using Avalonia.Utilities;
 
@@ -13,7 +14,7 @@ namespace Avalonia.Animation
         private TimeSpan _delay;
         private TimeSpan _duration;
         private readonly IClock _baseClock;
-        private IClock _clock;
+        private TransitionClock _clock;
 
         public TransitionInstance(IClock clock, TimeSpan delay, TimeSpan duration)
         {
@@ -71,7 +72,7 @@ namespace Avalonia.Animation
 
         protected override void Subscribed()
         {
-            _clock = new Clock(_baseClock);
+            _clock = new TransitionClock(_baseClock);
             _timerSubscription = _clock.Subscribe(this);
             PublishNext(0.0d);
         }
@@ -90,5 +91,37 @@ namespace Avalonia.Animation
         {
             TimerTick(value);
         }
+
+        /// <summary>
+        /// TODO: This clock is still fairly expensive due to <see cref="ClockBase"/> implementation.
+        /// </summary>
+        private sealed class TransitionClock : ClockBase, IObserver<TimeSpan>
+        {
+            private readonly IDisposable _parentSubscription;
+
+            public TransitionClock(IClock parent)
+            {
+                _parentSubscription = parent.Subscribe(this);
+            }
+
+            protected override void Stop()
+            {
+                _parentSubscription.Dispose();
+            }
+
+            void IObserver<TimeSpan>.OnNext(TimeSpan value)
+            {
+                Pulse(value);
+            }
+
+            void IObserver<TimeSpan>.OnCompleted()
+            {
+            }
+
+            void IObserver<TimeSpan>.OnError(Exception error)
+            {
+                ExceptionDispatchInfo.Capture(error).Throw();
+            }
+        }
     }
 }
diff --git a/src/Avalonia.Animation/TransitionObservableBase.cs b/src/Avalonia.Animation/TransitionObservableBase.cs
index 9f4fb8093c..c4ac803135 100644
--- a/src/Avalonia.Animation/TransitionObservableBase.cs
+++ b/src/Avalonia.Animation/TransitionObservableBase.cs
@@ -1,45 +1,58 @@
 using System;
+using Avalonia.Animation.Easings;
 using Avalonia.Reactive;
 
 #nullable enable
 
 namespace Avalonia.Animation
 {
+    /// <summary>
+    /// Provides base for observables implementing transitions.
+    /// </summary>
+    /// <typeparam name="T">Type of the transitioned value.</typeparam>
     public abstract class TransitionObservableBase<T> : SingleSubscriberObservableBase<T>, IObserver<double>
     {
+        private readonly Easing _easing;
         private readonly IObservable<double> _progress;
         private IDisposable? _progressSubscription;
 
-        protected TransitionObservableBase(IObservable<double> progress)
+        protected TransitionObservableBase(IObservable<double> progress, Easing easing)
         {
             _progress = progress;
+            _easing = easing;
         }
 
-        void IObserver<double>.OnCompleted()
+        /// <summary>
+        /// Produces value at given progress time point.
+        /// </summary>
+        /// <param name="progress">Transition progress.</param>
+        protected abstract T ProduceValue(double progress);
+
+        protected override void Subscribed()
         {
-            PublishCompleted();
+            _progressSubscription = _progress.Subscribe(this);
         }
 
-        void IObserver<double>.OnError(Exception error)
+        protected override void Unsubscribed()
         {
-            PublishError(error);
+            _progressSubscription?.Dispose();
         }
 
-        void IObserver<double>.OnNext(double value)
+        void IObserver<double>.OnCompleted()
         {
-            PublishNext(ProduceValue(value));
+            PublishCompleted();
         }
 
-        protected override void Unsubscribed()
+        void IObserver<double>.OnError(Exception error)
         {
-            _progressSubscription?.Dispose();
+            PublishError(error);
         }
 
-        protected override void Subscribed()
+        void IObserver<double>.OnNext(double value)
         {
-            _progressSubscription = _progress.Subscribe(this);
-        }
+            double progress = _easing.Ease(value);
 
-        protected abstract T ProduceValue(double progress);
+            PublishNext(ProduceValue(progress));
+        }
     }
 }
diff --git a/src/Avalonia.Animation/Transitions/DoubleTransition.cs b/src/Avalonia.Animation/Transitions/DoubleTransition.cs
index 28f630eb98..7232d87863 100644
--- a/src/Avalonia.Animation/Transitions/DoubleTransition.cs
+++ b/src/Avalonia.Animation/Transitions/DoubleTransition.cs
@@ -1,5 +1,3 @@
-using System;
-using System.Reactive.Linq;
 using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
@@ -10,16 +8,4 @@ namespace Avalonia.Animation
     public class DoubleTransition : AnimatorDrivenTransition<double, DoubleAnimator>
     {
     }
-
-    public class DoubleTransitionOld : Transition<double>
-    {
-        private static readonly DoubleAnimator s_animator = new DoubleAnimator();
-
-        /// <inheritdocs/>
-        public override IObservable<double> DoTransition(IObservable<double> progress, double oldValue, double newValue)
-        {
-            return progress
-                .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-        }
-    }
 }
diff --git a/src/Avalonia.Animation/Transitions/FloatTransition.cs b/src/Avalonia.Animation/Transitions/FloatTransition.cs
index 37b644fa96..a96db8ba5b 100644
--- a/src/Avalonia.Animation/Transitions/FloatTransition.cs
+++ b/src/Avalonia.Animation/Transitions/FloatTransition.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Reactive.Linq;
-
 using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
@@ -8,15 +5,7 @@ namespace Avalonia.Animation
     /// <summary>
     /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="float"/> types.
     /// </summary>  
-    public class FloatTransition : Transition<float>
+    public class FloatTransition : AnimatorDrivenTransition<float, FloatAnimator>
     {
-        private static readonly FloatAnimator s_animator = new FloatAnimator();
-
-        /// <inheritdocs/>
-        public override IObservable<float> DoTransition(IObservable<double> progress, float oldValue, float newValue)
-        {
-            return progress
-                .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-        }
     }
 }
diff --git a/src/Avalonia.Animation/Transitions/IntegerTransition.cs b/src/Avalonia.Animation/Transitions/IntegerTransition.cs
index 223b2ba531..343da7b689 100644
--- a/src/Avalonia.Animation/Transitions/IntegerTransition.cs
+++ b/src/Avalonia.Animation/Transitions/IntegerTransition.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Reactive.Linq;
-
 using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
@@ -8,15 +5,7 @@ namespace Avalonia.Animation
     /// <summary>
     /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="int"/> types.
     /// </summary>  
-    public class IntegerTransition : Transition<int>
+    public class IntegerTransition : AnimatorDrivenTransition<int, Int32Animator>
     {
-        private static readonly Int32Animator s_animator = new Int32Animator();
-
-        /// <inheritdocs/>
-        public override IObservable<int> DoTransition(IObservable<double> progress, int oldValue, int newValue)
-        {
-            return progress
-                .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-        }
     }
 }
diff --git a/src/Avalonia.Visuals/Animation/Transitions/BoxShadowsTransition.cs b/src/Avalonia.Visuals/Animation/Transitions/BoxShadowsTransition.cs
index 008613fb40..8a070836e9 100644
--- a/src/Avalonia.Visuals/Animation/Transitions/BoxShadowsTransition.cs
+++ b/src/Avalonia.Visuals/Animation/Transitions/BoxShadowsTransition.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Reactive.Linq;
-
 using Avalonia.Animation.Animators;
 using Avalonia.Media;
 
@@ -9,15 +6,7 @@ namespace Avalonia.Animation
     /// <summary>
     /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="BoxShadows"/> type.
     /// </summary>  
-    public class BoxShadowsTransition : Transition<BoxShadows>
+    public class BoxShadowsTransition : AnimatorDrivenTransition<BoxShadows, BoxShadowsAnimator>
     {
-        private static readonly BoxShadowsAnimator s_animator = new BoxShadowsAnimator();
-
-        /// <inheritdocs/>
-        public override IObservable<BoxShadows> DoTransition(IObservable<double> progress, BoxShadows oldValue, BoxShadows newValue)
-        {
-            return progress
-                .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-        }
     }
 }
diff --git a/src/Avalonia.Visuals/Animation/Transitions/ColorTransition.cs b/src/Avalonia.Visuals/Animation/Transitions/ColorTransition.cs
new file mode 100644
index 0000000000..9b925a3779
--- /dev/null
+++ b/src/Avalonia.Visuals/Animation/Transitions/ColorTransition.cs
@@ -0,0 +1,12 @@
+using Avalonia.Animation.Animators;
+using Avalonia.Media;
+
+namespace Avalonia.Animation
+{
+    /// <summary>
+    /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="Color"/> type.
+    /// </summary>
+    public class ColorTransition : AnimatorDrivenTransition<Color, ColorAnimator>
+    {
+    }
+}
diff --git a/src/Avalonia.Visuals/Animation/Transitions/CornerRadiusTransition.cs b/src/Avalonia.Visuals/Animation/Transitions/CornerRadiusTransition.cs
index 9ffdf53694..62b77a64e1 100644
--- a/src/Avalonia.Visuals/Animation/Transitions/CornerRadiusTransition.cs
+++ b/src/Avalonia.Visuals/Animation/Transitions/CornerRadiusTransition.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Reactive.Linq;
-
 using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
@@ -8,15 +5,7 @@ namespace Avalonia.Animation
     /// <summary>
     /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="CornerRadius"/> type.
     /// </summary>  
-    public class CornerRadiusTransition : Transition<CornerRadius>
+    public class CornerRadiusTransition : AnimatorDrivenTransition<CornerRadius, CornerRadiusAnimator>
     {
-        private static readonly CornerRadiusAnimator s_animator = new CornerRadiusAnimator();
-
-        /// <inheritdocs/>
-        public override IObservable<CornerRadius> DoTransition(IObservable<double> progress, CornerRadius oldValue, CornerRadius newValue)
-        {
-            return progress
-                .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-        }
     }
 }
diff --git a/src/Avalonia.Visuals/Animation/Transitions/PointTransition.cs b/src/Avalonia.Visuals/Animation/Transitions/PointTransition.cs
index fbe24c6d55..0985aaa8f8 100644
--- a/src/Avalonia.Visuals/Animation/Transitions/PointTransition.cs
+++ b/src/Avalonia.Visuals/Animation/Transitions/PointTransition.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Reactive.Linq;
-
 using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
@@ -8,15 +5,7 @@ namespace Avalonia.Animation
     /// <summary>
     /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="Point"/> type.
     /// </summary>  
-    public class PointTransition : Transition<Point>
+    public class PointTransition : AnimatorDrivenTransition<Point, PointAnimator>
     {
-        private static readonly PointAnimator s_animator = new PointAnimator();
-
-        /// <inheritdocs/>
-        public override IObservable<Point> DoTransition(IObservable<double> progress, Point oldValue, Point newValue)
-        {
-            return progress
-                .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-        }
     }
 }
diff --git a/src/Avalonia.Visuals/Animation/Transitions/SizeTransition.cs b/src/Avalonia.Visuals/Animation/Transitions/SizeTransition.cs
index 464f83bec7..6e59fb3631 100644
--- a/src/Avalonia.Visuals/Animation/Transitions/SizeTransition.cs
+++ b/src/Avalonia.Visuals/Animation/Transitions/SizeTransition.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Reactive.Linq;
-
 using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
@@ -8,15 +5,7 @@ namespace Avalonia.Animation
     /// <summary>
     /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="Size"/> type.
     /// </summary>  
-    public class SizeTransition : Transition<Size>
+    public class SizeTransition : AnimatorDrivenTransition<Size, SizeAnimator>
     {
-        private static readonly SizeAnimator s_animator = new SizeAnimator();
-
-        /// <inheritdocs/>
-        public override IObservable<Size> DoTransition(IObservable<double> progress, Size oldValue, Size newValue)
-        {
-            return progress
-                .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-        }
     }
 }
diff --git a/src/Avalonia.Visuals/Animation/Transitions/ThicknessTransition.cs b/src/Avalonia.Visuals/Animation/Transitions/ThicknessTransition.cs
index 9fb3380780..f50929348f 100644
--- a/src/Avalonia.Visuals/Animation/Transitions/ThicknessTransition.cs
+++ b/src/Avalonia.Visuals/Animation/Transitions/ThicknessTransition.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Reactive.Linq;
-
 using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
@@ -8,15 +5,7 @@ namespace Avalonia.Animation
     /// <summary>
     /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="Thickness"/> type.
     /// </summary>  
-    public class ThicknessTransition : Transition<Thickness>
+    public class ThicknessTransition : AnimatorDrivenTransition<Thickness, ThicknessAnimator>
     {
-        private static readonly ThicknessAnimator s_animator = new ThicknessAnimator();
-
-        /// <inheritdocs/>
-        public override IObservable<Thickness> DoTransition(IObservable<double> progress, Thickness oldValue, Thickness newValue)
-        {
-            return progress
-                .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-        }
     }
 }
diff --git a/src/Avalonia.Visuals/Animation/Transitions/VectorTransition.cs b/src/Avalonia.Visuals/Animation/Transitions/VectorTransition.cs
index 5038117faa..596989fbae 100644
--- a/src/Avalonia.Visuals/Animation/Transitions/VectorTransition.cs
+++ b/src/Avalonia.Visuals/Animation/Transitions/VectorTransition.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Reactive.Linq;
-
 using Avalonia.Animation.Animators;
 
 namespace Avalonia.Animation
@@ -8,15 +5,7 @@ namespace Avalonia.Animation
     /// <summary>
     /// Transition class that handles <see cref="AvaloniaProperty"/> with <see cref="Vector"/> type.
     /// </summary>  
-    public class VectorTransition : Transition<Vector>
+    public class VectorTransition : AnimatorDrivenTransition<Vector, VectorAnimator>
     {
-        private static readonly VectorAnimator s_animator = new VectorAnimator();
-
-        /// <inheritdocs/>
-        public override IObservable<Vector> DoTransition(IObservable<double> progress, Vector oldValue, Vector newValue)
-        {
-            return progress
-                .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-        }
     }
 }
diff --git a/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs b/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs
index 16aad0c21b..aba59d4585 100644
--- a/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs
+++ b/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs
@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Runtime.CompilerServices;
 using Avalonia.Animation;
+using Avalonia.Animation.Animators;
 using Avalonia.Layout;
 using BenchmarkDotNet.Attributes;
 
@@ -14,26 +16,29 @@ namespace Avalonia.Benchmarks.Animations
     {
         private readonly DoubleTransition _transition;
         private readonly DoubleTransitionOld _oldTransition;
-        private readonly int _frameCount;
         private readonly Subject<double> _timeProducer;
         private readonly List<double> _producedValues;
+        private readonly AddValueObserver _observer;
+
+        [Params(10, 100)]
+        public int FrameCount { get; set; }
 
         public TransitionBenchmark()
         {
-            _frameCount = 100;
-
             _oldTransition = new DoubleTransitionOld
             {
-                Duration = TimeSpan.FromMilliseconds(_frameCount), Property = Layoutable.WidthProperty
+                Duration = TimeSpan.FromMilliseconds(FrameCount), Property = Layoutable.WidthProperty
             };
 
             _transition = new DoubleTransition
             {
-                Duration = TimeSpan.FromMilliseconds(_frameCount), Property = Layoutable.WidthProperty
+                Duration = TimeSpan.FromMilliseconds(FrameCount), Property = Layoutable.WidthProperty
             };
 
             _timeProducer = new Subject<double>();
-            _producedValues = new List<double>(_frameCount);
+            _producedValues = new List<double>(FrameCount);
+
+            _observer = new AddValueObserver(_producedValues);
         }
 
         [Benchmark(Baseline = true)]
@@ -56,14 +61,26 @@ namespace Avalonia.Benchmarks.Animations
 
             _producedValues.Clear();
 
-            using var transitionSub = transitionObs.Subscribe(new AddValueObserver(_producedValues));
+            using var transitionSub = transitionObs.Subscribe(_observer);
 
-            for (int i = 0; i < _frameCount; i++)
+            for (int i = 0; i < FrameCount; i++)
             {
-                _timeProducer.OnNext(TimeSpan.FromMilliseconds(i).TotalSeconds);
+                _timeProducer.OnNext(i/1000d);
             }
 
-            Debug.Assert(_producedValues.Count == _frameCount);
+            Debug.Assert(_producedValues.Count == FrameCount);
+        }
+
+        private class DoubleTransitionOld : Transition<double>
+        {
+            private static readonly DoubleAnimator s_animator = new DoubleAnimator();
+
+            /// <inheritdocs/>
+            public override IObservable<double> DoTransition(IObservable<double> progress, double oldValue, double newValue)
+            {
+                return progress
+                    .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
+            }
         }
 
         private class AddValueObserver : IObserver<double>

From 78f7726289cf8a002c36f33ac49153e33407528b Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 28 May 2021 17:09:14 +0200
Subject: [PATCH 7/9] Don't activate window when extending client area.

Fixes #5988
---
 src/Windows/Avalonia.Win32/WindowImpl.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index 082aca1109..3a3342fd14 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -900,7 +900,7 @@ namespace Avalonia.Win32
                 IntPtr.Zero,
                 rcWindow.left, rcWindow.top,
                 rcClient.Width, rcClient.Height,
-                SetWindowPosFlags.SWP_FRAMECHANGED);
+                SetWindowPosFlags.SWP_FRAMECHANGED | SetWindowPosFlags.SWP_NOACTIVATE);
 
             if (_isClientAreaExtended && WindowState != WindowState.FullScreen)
             {

From a21880d4a8e8b51e51af6098a1b32d9727056576 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Sun, 30 May 2021 12:31:53 +0200
Subject: [PATCH 8/9] Remove old implementation benchmark.

---
 .../Animations/TransitionBenchmark.cs         | 43 +++----------------
 1 file changed, 6 insertions(+), 37 deletions(-)

diff --git a/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs b/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs
index aba59d4585..f74457a924 100644
--- a/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs
+++ b/tests/Avalonia.Benchmarks/Animations/TransitionBenchmark.cs
@@ -14,22 +14,13 @@ namespace Avalonia.Benchmarks.Animations
     [MemoryDiagnoser]
     public class TransitionBenchmark
     {
-        private readonly DoubleTransition _transition;
-        private readonly DoubleTransitionOld _oldTransition;
-        private readonly Subject<double> _timeProducer;
-        private readonly List<double> _producedValues;
         private readonly AddValueObserver _observer;
-
-        [Params(10, 100)]
-        public int FrameCount { get; set; }
+        private readonly List<double> _producedValues;
+        private readonly Subject<double> _timeProducer;
+        private readonly DoubleTransition _transition;
 
         public TransitionBenchmark()
         {
-            _oldTransition = new DoubleTransitionOld
-            {
-                Duration = TimeSpan.FromMilliseconds(FrameCount), Property = Layoutable.WidthProperty
-            };
-
             _transition = new DoubleTransition
             {
                 Duration = TimeSpan.FromMilliseconds(FrameCount), Property = Layoutable.WidthProperty
@@ -41,23 +32,13 @@ namespace Avalonia.Benchmarks.Animations
             _observer = new AddValueObserver(_producedValues);
         }
 
-        [Benchmark(Baseline = true)]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        public void OldTransition()
-        {
-            TransitionCommon(_oldTransition);
-        }
+        [Params(10, 100)] public int FrameCount { get; set; }
 
         [Benchmark]
         [MethodImpl(MethodImplOptions.NoInlining)]
         public void NewTransition()
         {
-            TransitionCommon(_transition);
-        }
-
-        private void TransitionCommon(Transition<double> transition)
-        {
-            var transitionObs = transition.DoTransition(_timeProducer, 0, 1);
+            var transitionObs = _transition.DoTransition(_timeProducer, 0, 1);
 
             _producedValues.Clear();
 
@@ -65,24 +46,12 @@ namespace Avalonia.Benchmarks.Animations
 
             for (int i = 0; i < FrameCount; i++)
             {
-                _timeProducer.OnNext(i/1000d);
+                _timeProducer.OnNext(i / 1000d);
             }
 
             Debug.Assert(_producedValues.Count == FrameCount);
         }
 
-        private class DoubleTransitionOld : Transition<double>
-        {
-            private static readonly DoubleAnimator s_animator = new DoubleAnimator();
-
-            /// <inheritdocs/>
-            public override IObservable<double> DoTransition(IObservable<double> progress, double oldValue, double newValue)
-            {
-                return progress
-                    .Select(progress => s_animator.Interpolate(Easing.Ease(progress), oldValue, newValue));
-            }
-        }
-
         private class AddValueObserver : IObserver<double>
         {
             private readonly List<double> _values;

From 86b9a60a4c2c037b32674a65cd01796cfab7727f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Wies=C5=82aw=20=C5=A0olt=C3=A9s?=
 <wieslawsoltes@users.noreply.github.com>
Date: Mon, 31 May 2021 09:41:49 -0700
Subject: [PATCH 9/9] Fix custom hit testing (#5968)

* Fix custom hit testing
* Use ICustomHitTest as it's intended to be used in defered renderer

Co-authored-by: Dan Walmsley <dan@walms.co.uk>
Co-authored-by: Steven Kirk <grokys@users.noreply.github.com>
Co-authored-by: Steven Kirk <grokys@gmail.com>
---
 src/Avalonia.Controls/Primitives/LightDismissOverlayLayer.cs | 3 +--
 src/Avalonia.Visuals/Rendering/SceneGraph/Scene.cs           | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Controls/Primitives/LightDismissOverlayLayer.cs b/src/Avalonia.Controls/Primitives/LightDismissOverlayLayer.cs
index 1d655bb691..74d804f2bf 100644
--- a/src/Avalonia.Controls/Primitives/LightDismissOverlayLayer.cs
+++ b/src/Avalonia.Controls/Primitives/LightDismissOverlayLayer.cs
@@ -52,8 +52,7 @@ namespace Avalonia.Controls.Primitives
         {
             if (InputPassThroughElement is object)
             {
-                var p = point.Transform(this.TransformToVisual(VisualRoot)!.Value);
-                var hit = VisualRoot.GetVisualAt(p, x => x != this);
+                var hit = VisualRoot.GetVisualAt(point, x => x != this);
 
                 if (hit is object)
                 {
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/Scene.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/Scene.cs
index 36aa08c2f9..d8e5baac97 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/Scene.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/Scene.cs
@@ -257,7 +257,7 @@ namespace Avalonia.Rendering.SceneGraph
                     if (childCount == 0 || wasVisited)
                     {
                         if ((wasVisited || FilterAndClip(node, ref clip)) &&
-                            (node.Visual is ICustomSimpleHitTest custom ? custom.HitTest(_point) : node.HitTest(_point)))
+                            (node.Visual is ICustomHitTest custom ? custom.HitTest(_point) : node.HitTest(_point)))
                         {
                             _current = node.Visual;