Browse Source
- animation/layout/render cycle is now managed from a central location - animations are now throttled if animation/layout/render pass takes longer than a frame which previously caused a soft-freeze with input not being processed - the public API is trimmed to make sure that we can make other planned changes during the 11.x support cycle "Changelog": - IClock is hidden and is planned to be replaced later - Animator classes are hidden and are planned to be refactored later - IAnimation members are hidden, it's supposed to be a marker interface for Style.Animations collection now, to start animations manually use Animation.RunAsync - Sealed several classes in Avalonia.Animation namespace - Spring class is removed from the public API (it wasn't possible to use it directly in a meaningful way anyway) - Sealed brushes, transforms, effects and drawings - Removed separate dispatcher priorities for Layout and Composition, everything now happens from a central place with Render priority (same as WPF) - - some private "hook" priorities are added for now, those will be removed later - IRenderLoop is hidden and removed from locator - IRenderer is hidden (the plan is to remove that concept later) - - Renderer.Start/Stop exposed as StartRendering/StopRendering on the toplevel (will be on a CompositionTarget/PresentationSource-like type later) - - Renderer.Diagnistics exposed as RendererDiagnostics (same) - - Renderer is no longer created by the platform code and is created by TopLevel itself - - From the user-code hit-testing should be done by VisualExtensions.GetVisual(s)At, which has the same features - - For unit tests a separate IHitTester interface is added which can be changed for a particular toplevel - ILayoutManager is hidden - - LayoutManager.ExecuteLayoutPass() exposed as TopLevel.UpdateLayout() - Custom animators now have a separate base class that only deals with interpolation Minor improvements: - Compositor has a mode that doesn't use DispatcherTimers, useful for unit tests - Introduced ScopedTestBase that auto-resets the locator when test is finishedpull/11556/head
Nikita Tsukanov
3 years ago
201 changed files with 1254 additions and 821 deletions
@ -0,0 +1,30 @@ |
|||
using System; |
|||
using Avalonia.Animation.Animators; |
|||
|
|||
namespace Avalonia.Animation; |
|||
|
|||
public abstract class CustomAnimatorBase |
|||
{ |
|||
internal abstract IAnimator CreateWrapper(); |
|||
internal abstract Type WrapperType { get; } |
|||
} |
|||
|
|||
public abstract class CustomAnimatorBase<T> : CustomAnimatorBase |
|||
{ |
|||
public abstract T Interpolate(double progress, T oldValue, T newValue); |
|||
|
|||
internal override Type WrapperType => typeof(AnimatorWrapper); |
|||
internal override IAnimator CreateWrapper() => new AnimatorWrapper(this); |
|||
|
|||
internal class AnimatorWrapper : Animator<T> |
|||
{ |
|||
private readonly CustomAnimatorBase<T> _parent; |
|||
|
|||
public AnimatorWrapper(CustomAnimatorBase<T> parent) |
|||
{ |
|||
_parent = parent; |
|||
} |
|||
|
|||
public override T Interpolate(double progress, T oldValue, T newValue) => _parent.Interpolate(progress, oldValue, newValue); |
|||
} |
|||
} |
|||
@ -1,26 +0,0 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Text; |
|||
using Avalonia.Rendering; |
|||
|
|||
namespace Avalonia.Animation |
|||
{ |
|||
public class RenderLoopClock : ClockBase, IRenderLoopTask, IGlobalClock |
|||
{ |
|||
protected override void Stop() |
|||
{ |
|||
AvaloniaLocator.Current.GetRequiredService<IRenderLoop>().Remove(this); |
|||
} |
|||
|
|||
bool IRenderLoopTask.NeedsUpdate => HasSubscriptions; |
|||
|
|||
void IRenderLoopTask.Render() |
|||
{ |
|||
} |
|||
|
|||
void IRenderLoopTask.Update(TimeSpan time) |
|||
{ |
|||
Pulse(time); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,53 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Diagnostics; |
|||
using Avalonia.Animation; |
|||
using Avalonia.Reactive; |
|||
using Avalonia.Threading; |
|||
|
|||
namespace Avalonia.Media; |
|||
|
|||
internal partial class MediaContext |
|||
{ |
|||
private readonly MediaContextClock _clock; |
|||
public IGlobalClock Clock => _clock; |
|||
private readonly Stopwatch _time = Stopwatch.StartNew(); |
|||
|
|||
class MediaContextClock : IGlobalClock |
|||
{ |
|||
private readonly MediaContext _parent; |
|||
private List<IObserver<TimeSpan>> _observers = new(); |
|||
public bool HasNewSubscriptions { get; set; } |
|||
public bool HasSubscriptions => _observers.Count > 0; |
|||
|
|||
public MediaContextClock(MediaContext parent) |
|||
{ |
|||
_parent = parent; |
|||
} |
|||
|
|||
public IDisposable Subscribe(IObserver<TimeSpan> observer) |
|||
{ |
|||
_parent.ScheduleRender(false); |
|||
Dispatcher.UIThread.VerifyAccess(); |
|||
HasNewSubscriptions = true; |
|||
_observers.Add(observer); |
|||
return Disposable.Create(() => |
|||
{ |
|||
Dispatcher.UIThread.VerifyAccess(); |
|||
_observers.Remove(observer); |
|||
}); |
|||
} |
|||
|
|||
public void Pulse(TimeSpan now) |
|||
{ |
|||
foreach (var observer in _observers.ToArray()) |
|||
observer.OnNext(now); |
|||
} |
|||
|
|||
public PlayState PlayState |
|||
{ |
|||
get => PlayState.Run; |
|||
set => throw new InvalidOperationException(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,135 @@ |
|||
using System; |
|||
using System.Threading.Tasks; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Rendering.Composition; |
|||
using Avalonia.Rendering.Composition.Transport; |
|||
using Avalonia.Threading; |
|||
|
|||
namespace Avalonia.Media; |
|||
|
|||
partial class MediaContext |
|||
{ |
|||
private bool _scheduleCommitOnLastCompositionBatchCompletion; |
|||
|
|||
/// <summary>
|
|||
/// Actually sends the current batch to the compositor and does the required housekeeping
|
|||
/// This is the only place that should be allowed to call Commit
|
|||
/// </summary>
|
|||
private Batch CommitCompositor(Compositor compositor) |
|||
{ |
|||
var commit = compositor.Commit(); |
|||
_requestedCommits.Remove(compositor); |
|||
_pendingCompositionBatches[compositor] = commit; |
|||
commit.Processed.ContinueWith(_ => |
|||
Dispatcher.UIThread.Post(() => CompositionBatchFinished(compositor, commit), DispatcherPriority.Send)); |
|||
return commit; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Handles batch completion, required to re-schedule a render pass if one was skipped due to compositor throttling
|
|||
/// </summary>
|
|||
private void CompositionBatchFinished(Compositor compositor, Batch batch) |
|||
{ |
|||
// Check if it was the last commited batch, since sometimes we are forced to send a new
|
|||
// one without waiting for the previous one to complete
|
|||
if (_pendingCompositionBatches.TryGetValue(compositor, out var waitingForBatch) && waitingForBatch == batch) |
|||
_pendingCompositionBatches.Remove(compositor); |
|||
|
|||
if (_pendingCompositionBatches.Count == 0) |
|||
{ |
|||
_animationsAreWaitingForComposition = false; |
|||
|
|||
// Check if we have uncommited changes
|
|||
if (_scheduleCommitOnLastCompositionBatchCompletion && _pendingCompositionBatches.Count > 0) |
|||
{ |
|||
CommitCompositorsWithThrottling(); |
|||
_scheduleCommitOnLastCompositionBatchCompletion = false; |
|||
} |
|||
// Check if there are active animations and schedule the next render
|
|||
else if(_clock.HasSubscriptions) |
|||
ScheduleRender(false); |
|||
} |
|||
|
|||
} |
|||
|
|||
private bool CommitCompositorsWithThrottling() |
|||
{ |
|||
// Check if we are still waiting for previous composition batches
|
|||
if (_pendingCompositionBatches.Count > 0) |
|||
{ |
|||
_scheduleCommitOnLastCompositionBatchCompletion = true; |
|||
return true; |
|||
} |
|||
|
|||
if (_requestedCommits.Count == 0) |
|||
return false; |
|||
|
|||
foreach (var c in _requestedCommits) |
|||
CommitCompositor(c); |
|||
|
|||
_requestedCommits.Clear(); |
|||
return true; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Executes a synchronous commit when we need to wait for composition jobs to be done
|
|||
/// Is used in resize and TopLevel destruction scenarios
|
|||
/// </summary>
|
|||
private void SyncCommit(Compositor compositor, bool waitFullRender) |
|||
{ |
|||
// Unit tests are assuming that they can call any API without setting up platforms
|
|||
if (AvaloniaLocator.Current.GetService<IPlatformRenderInterface>() == null) |
|||
return; |
|||
|
|||
if (compositor is |
|||
{ |
|||
UseUiThreadForSynchronousCommits: false, |
|||
Loop.RunsInBackground: true |
|||
}) |
|||
{ |
|||
var batch = CommitCompositor(compositor); |
|||
(waitFullRender ? batch.Rendered : batch.Processed).Wait(); |
|||
} |
|||
else |
|||
{ |
|||
CommitCompositor(compositor); |
|||
compositor.Server.Render(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// This method handles synchronous rendering of a surface when requested by the OS (typically during the resize)
|
|||
/// </summary>
|
|||
// TODO: do we need to execute a render pass here too?
|
|||
// We've previously tried that and it made the resize experience worse
|
|||
public void ImmediateRenderRequested(CompositionTarget target) |
|||
{ |
|||
SyncCommit(target.Compositor, true); |
|||
} |
|||
|
|||
|
|||
/// <summary>
|
|||
/// This method handles synchronous destruction of the composition target, so we are guaranteed
|
|||
/// to release all resources when a TopLevel is being destroyed
|
|||
/// </summary>
|
|||
public void SyncDisposeCompositionTarget(CompositionTarget compositionTarget) |
|||
{ |
|||
compositionTarget.Dispose(); |
|||
|
|||
// TODO: introduce a way to skip any actual rendering for other targets and only do a dispose?
|
|||
SyncCommit(compositionTarget.Compositor, false); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// This method schedules a render when something has called RequestCommitAsync
|
|||
/// This can be triggered by user code outside of our normal layout and rendering
|
|||
/// </summary>
|
|||
void ICompositorScheduler.CommitRequested(Compositor compositor) |
|||
{ |
|||
if(!_requestedCommits.Add(compositor)) |
|||
return; |
|||
|
|||
// TODO: maybe skip the full render here?
|
|||
ScheduleRender(true); |
|||
} |
|||
} |
|||
@ -0,0 +1,171 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using System.Threading.Tasks; |
|||
using Avalonia.Animation; |
|||
using Avalonia.Layout; |
|||
using Avalonia.Rendering; |
|||
using Avalonia.Rendering.Composition; |
|||
using Avalonia.Rendering.Composition.Transport; |
|||
using Avalonia.Threading; |
|||
|
|||
namespace Avalonia.Media; |
|||
|
|||
internal partial class MediaContext : ICompositorScheduler |
|||
{ |
|||
private DispatcherOperation? _nextRenderOp; |
|||
private DispatcherOperation? _inputMarkerOp; |
|||
private TimeSpan _inputMarkerAddedAt; |
|||
private bool _animationsAreWaitingForComposition; |
|||
private const double MaxSecondsWithoutInput = 1; |
|||
private readonly Action _render; |
|||
private readonly Action _inputMarkerHandler; |
|||
private readonly HashSet<Compositor> _requestedCommits = new(); |
|||
private readonly Dictionary<Compositor, Batch> _pendingCompositionBatches = new(); |
|||
private record TopLevelInfo(Compositor Compositor, CompositingRenderer Renderer, ILayoutManager LayoutManager); |
|||
private readonly HashSet<LayoutManager> _queuedLayoutManagers = new(); |
|||
public static bool InputMarkerEnabled = true; |
|||
|
|||
private Dictionary<object, TopLevelInfo> _topLevels = new(); |
|||
|
|||
private MediaContext() |
|||
{ |
|||
_render = Render; |
|||
_inputMarkerHandler = InputMarkerHandler; |
|||
_clock = new(this); |
|||
} |
|||
|
|||
public static MediaContext Instance |
|||
{ |
|||
get |
|||
{ |
|||
// Technically it's supposed to be a thread-static singleton, but we don't have multiple threads
|
|||
// and need to do a full reset for unit tests
|
|||
var context = AvaloniaLocator.Current.GetService<MediaContext>(); |
|||
if (context == null) |
|||
AvaloniaLocator.CurrentMutable.Bind<MediaContext>().ToConstant(context = new()); |
|||
return context; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Schedules the next render operation, handles render throttling for input processing
|
|||
/// </summary>
|
|||
private void ScheduleRender(bool now) |
|||
{ |
|||
// Already scheduled, nothing to do
|
|||
if (_nextRenderOp != null) |
|||
{ |
|||
if (now) |
|||
_nextRenderOp.Priority = DispatcherPriority.Render; |
|||
return; |
|||
} |
|||
// Sometimes our animation, layout and render passes might be taking more than a frame to complete
|
|||
// which can cause a "freeze"-like state when UI is being updated, but input is never being processed
|
|||
// So here we inject an operation with Input priority to check if Input wasn't being processed
|
|||
// for a long time. If that's the case the next rendering operation will be scheduled to happen after all pending input
|
|||
|
|||
var priority = DispatcherPriority.Render; |
|||
|
|||
if (InputMarkerEnabled) |
|||
{ |
|||
if (_inputMarkerOp == null) |
|||
{ |
|||
_inputMarkerOp = Dispatcher.UIThread.InvokeAsync(_inputMarkerHandler, DispatcherPriority.Input); |
|||
_inputMarkerAddedAt = _time.Elapsed; |
|||
} |
|||
else if (!now && (_time.Elapsed - _inputMarkerAddedAt).TotalSeconds > MaxSecondsWithoutInput) |
|||
{ |
|||
priority = DispatcherPriority.Input; |
|||
} |
|||
} |
|||
|
|||
_nextRenderOp = Dispatcher.UIThread.InvokeAsync(_render, priority); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// This handles the _inputMarkerOp message. We're using
|
|||
/// _inputMarkerOp to determine if input priority dispatcher ops
|
|||
/// have been processes.
|
|||
/// </summary>
|
|||
private void InputMarkerHandler() |
|||
{ |
|||
//set the marker to null so we know that input priority has been processed
|
|||
_inputMarkerOp = null; |
|||
} |
|||
|
|||
private void Render() |
|||
{ |
|||
try |
|||
{ |
|||
RenderCore(); |
|||
} |
|||
finally |
|||
{ |
|||
_nextRenderOp = null; |
|||
} |
|||
} |
|||
|
|||
private void RenderCore() |
|||
{ |
|||
var now = _time.Elapsed; |
|||
if (!_animationsAreWaitingForComposition) |
|||
_clock.Pulse(now); |
|||
|
|||
// Since new animations could be started during the layout and can affect layout/render
|
|||
// We are doing several iterations when it happens
|
|||
for (var c = 0; c < 10; c++) |
|||
{ |
|||
_clock.HasNewSubscriptions = false; |
|||
//TODO: Integrate LayoutManager's attempt limit here
|
|||
foreach (var layout in _queuedLayoutManagers.ToArray()) |
|||
layout.ExecuteQueuedLayoutPass(); |
|||
_queuedLayoutManagers.Clear(); |
|||
|
|||
if (_clock.HasNewSubscriptions) |
|||
{ |
|||
_clock.Pulse(now); |
|||
continue; |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
// We are currently using compositor commit callbacks to drive animations
|
|||
// Later we should use WPF's approach that asks the animation system for the next tick time
|
|||
// and use some timer if the next animation frame is not needed to be sent to the compositor immediately
|
|||
if (_requestedCommits.Count > 0 || _clock.HasSubscriptions) |
|||
{ |
|||
_animationsAreWaitingForComposition = true; |
|||
CommitCompositorsWithThrottling(); |
|||
} |
|||
} |
|||
|
|||
// Used for unit tests
|
|||
public bool IsTopLevelActive(object key) => _topLevels.ContainsKey(key); |
|||
|
|||
public void AddTopLevel(object key, ILayoutManager layoutManager, IRenderer renderer) |
|||
{ |
|||
if(_topLevels.ContainsKey(key)) |
|||
return; |
|||
var render = (CompositingRenderer)renderer; |
|||
_topLevels.Add(key, new TopLevelInfo(render.Compositor, render, layoutManager)); |
|||
render.Start(); |
|||
ScheduleRender(true); |
|||
} |
|||
|
|||
public void RemoveTopLevel(object key) |
|||
{ |
|||
if (_topLevels.TryGetValue(key, out var info)) |
|||
{ |
|||
_topLevels.Remove(key); |
|||
info.Renderer.Stop(); |
|||
} |
|||
} |
|||
|
|||
public void QueueLayoutPass(LayoutManager layoutManager) |
|||
{ |
|||
_queuedLayoutManagers.Add(layoutManager); |
|||
ScheduleRender(true); |
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue