Browse Source
* Prototype an AABB tree for hit testing * Some optimizations * Revert runtime knobs and add tests * Avoid rebuilding the whole tree * Revert an invalid optimization * Add a hit test page * Clean up * Format code * Nit * Use weak CompositionVisual reference in server-side * Bucket composition hit-test AABB tree by child order * Use readback revisions for AABB hit-test updatespull/21397/head
Steve
5 months ago
committed by
GitHub
GitHub
9 changed files with 1678 additions and 34 deletions
@ -0,0 +1,401 @@ |
|||
using System; |
|||
using System.Diagnostics; |
|||
using System.Numerics; |
|||
using Avalonia; |
|||
using Avalonia.Animation; |
|||
using Avalonia.Animation.Easings; |
|||
using Avalonia.Controls; |
|||
using Avalonia.Input; |
|||
using Avalonia.Media; |
|||
using Avalonia.Rendering.Composition; |
|||
using Avalonia.Rendering.Composition.Animations; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace RenderDemo.Pages |
|||
{ |
|||
public class HitTestingPage : UserControl |
|||
{ |
|||
private const int GroupColumns = 8; |
|||
private const int GroupRows = 5; |
|||
private const int CellsPerGroupSide = 10; |
|||
private const int CellStride = 10; |
|||
private const int CellSize = 8; |
|||
private const int AnimationTravel = 64; |
|||
|
|||
private readonly Canvas _scene; |
|||
private readonly TextBlock _stats; |
|||
private readonly Cell[] _cells = new Cell[GroupColumns * GroupRows * CellsPerGroupSide * CellsPerGroupSide]; |
|||
private readonly Stopwatch _stopwatch = Stopwatch.StartNew(); |
|||
private Compositor? _compositor; |
|||
private int _hitTestsPerFrame = 256; |
|||
private int _updateCount; |
|||
private int _hitTestCount; |
|||
private int _hitCount; |
|||
private int _lastSecondUpdateCount; |
|||
private int _lastSecondHitTestCount; |
|||
private int _lastSecondHitCount; |
|||
private TimeSpan _lastSecondTime; |
|||
private double _lastSecondUpdatesPerSecond; |
|||
private double _lastSecondHitTestsPerSecond; |
|||
private double _lastSecondHitsPerSecond; |
|||
private int _clickCount; |
|||
private bool _isAttached; |
|||
private bool _updateQueued; |
|||
private bool _animationsStarted; |
|||
private Cell? _lastHitCell; |
|||
private Cell? _lastClickedCell; |
|||
|
|||
public HitTestingPage() |
|||
{ |
|||
_scene = new Canvas |
|||
{ |
|||
Width = GroupColumns * CellsPerGroupSide * CellStride, |
|||
Height = GroupRows * CellsPerGroupSide * CellStride, |
|||
Background = Brushes.Transparent |
|||
}; |
|||
|
|||
_stats = new TextBlock |
|||
{ |
|||
HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Center, |
|||
VerticalAlignment = Avalonia.Layout.VerticalAlignment.Top, |
|||
Margin = new Thickness(12), |
|||
Padding = new Thickness(8, 4), |
|||
Background = new SolidColorBrush(Color.FromArgb(220, 255, 255, 255)), |
|||
Foreground = Brushes.Black, |
|||
IsHitTestVisible = false |
|||
}; |
|||
|
|||
var numberOfHitTests = new NumericUpDown |
|||
{ |
|||
Minimum = 0, |
|||
Value = _hitTestsPerFrame, |
|||
Width = 200, |
|||
HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Left, |
|||
VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center |
|||
}; |
|||
|
|||
numberOfHitTests.ValueChanged += (s, e) => |
|||
{ |
|||
if (numberOfHitTests.Value.HasValue) |
|||
{ |
|||
_hitTestsPerFrame = (int)numberOfHitTests.Value.Value; |
|||
} |
|||
}; |
|||
|
|||
var param = new StackPanel |
|||
{ |
|||
Orientation = Avalonia.Layout.Orientation.Horizontal, |
|||
HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Left, |
|||
VerticalAlignment = Avalonia.Layout.VerticalAlignment.Bottom, |
|||
Margin = new Thickness(12), |
|||
Spacing = 8, |
|||
Children = |
|||
{ |
|||
new TextBlock { Text = "Hit tests per update:" }, |
|||
numberOfHitTests |
|||
} |
|||
}; |
|||
|
|||
var root = new Grid |
|||
{ |
|||
ClipToBounds = true, |
|||
RowDefinitions = |
|||
{ |
|||
new RowDefinition(GridLength.Auto), |
|||
new RowDefinition(GridLength.Auto), |
|||
new RowDefinition(GridLength.Star), |
|||
}, |
|||
}; |
|||
|
|||
Grid.SetRow(param, 0); |
|||
root.Children.Add(param); |
|||
Grid.SetRow(_stats, 1); |
|||
root.Children.Add(_stats); |
|||
Grid.SetRow(_scene, 2); |
|||
root.Children.Add(_scene); |
|||
|
|||
Content = root; |
|||
BuildScene(); |
|||
ResetState(); |
|||
} |
|||
|
|||
protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e) |
|||
{ |
|||
base.OnAttachedToVisualTree(e); |
|||
ResetState(); |
|||
_compositor = ElementComposition.GetElementVisual(this)?.Compositor; |
|||
_isAttached = true; |
|||
RequestNextUpdate(); |
|||
} |
|||
|
|||
protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e) |
|||
{ |
|||
_isAttached = false; |
|||
_updateQueued = false; |
|||
_compositor = null; |
|||
ResetState(); |
|||
base.OnDetachedFromVisualTree(e); |
|||
} |
|||
|
|||
private void BuildScene() |
|||
{ |
|||
var index = 0; |
|||
var groupSize = CellsPerGroupSide * CellStride; |
|||
|
|||
for (var groupY = 0; groupY < GroupRows; groupY++) |
|||
{ |
|||
for (var groupX = 0; groupX < GroupColumns; groupX++) |
|||
{ |
|||
var group = new Canvas |
|||
{ |
|||
Width = groupSize, |
|||
Height = groupSize, |
|||
Background = Brushes.Transparent |
|||
}; |
|||
Canvas.SetLeft(group, groupX * groupSize); |
|||
Canvas.SetTop(group, groupY * groupSize); |
|||
_scene.Children.Add(group); |
|||
|
|||
for (var y = 0; y < CellsPerGroupSide; y++) |
|||
{ |
|||
for (var x = 0; x < CellsPerGroupSide; x++) |
|||
{ |
|||
var cell = new Cell(index) |
|||
{ |
|||
Width = CellSize, |
|||
Height = CellSize, |
|||
Background = CreateBrush(index), |
|||
RenderTransformOrigin = new RelativePoint(0.5, 0.5, RelativeUnit.Relative) |
|||
}; |
|||
cell.PointerPressed += OnCellPointerPressed; |
|||
|
|||
Canvas.SetLeft(cell, x * CellStride); |
|||
Canvas.SetTop(cell, y * CellStride); |
|||
group.Children.Add(cell); |
|||
_cells[index++] = cell; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void OnCompositionUpdate() |
|||
{ |
|||
_updateQueued = false; |
|||
|
|||
if (!_isAttached) |
|||
return; |
|||
|
|||
if (!_animationsStarted) |
|||
StartAnimations(); |
|||
|
|||
RunHitTests(); |
|||
|
|||
_updateCount++; |
|||
if (_stopwatch.Elapsed - _lastSecondTime >= TimeSpan.FromSeconds(1)) |
|||
UpdateStats(); |
|||
|
|||
RequestNextUpdate(); |
|||
} |
|||
|
|||
private void RequestNextUpdate() |
|||
{ |
|||
if (_updateQueued || _compositor == null) |
|||
return; |
|||
|
|||
_updateQueued = true; |
|||
_compositor.RequestCompositionUpdate(OnCompositionUpdate); |
|||
} |
|||
|
|||
private void StartAnimations() |
|||
{ |
|||
var started = 0; |
|||
var easing = new SineEaseInOut(); |
|||
|
|||
for (var i = 0; i < _cells.Length; i++) |
|||
{ |
|||
if (i % 5 != 0) |
|||
continue; |
|||
|
|||
var visual = ElementComposition.GetElementVisual(_cells[i]); |
|||
if (visual == null) |
|||
continue; |
|||
|
|||
var translation = visual.Compositor.CreateVector3KeyFrameAnimation(); |
|||
translation.Target = "Translation"; |
|||
translation.Duration = TimeSpan.FromMilliseconds(900 + (i % 700)); |
|||
translation.Direction = PlaybackDirection.Alternate; |
|||
translation.IterationBehavior = AnimationIterationBehavior.Forever; |
|||
translation.InsertKeyFrame(0f, new Vector3(0, 0, 0), easing); |
|||
translation.InsertKeyFrame(1f, GetAnimationOffset(i), easing); |
|||
visual.StartAnimation("Translation", translation); |
|||
|
|||
started++; |
|||
} |
|||
|
|||
_animationsStarted = started > 0; |
|||
} |
|||
|
|||
private void StopAnimations() |
|||
{ |
|||
for (var i = 0; i < _cells.Length; i++) |
|||
{ |
|||
var visual = ElementComposition.GetElementVisual(_cells[i]); |
|||
if (visual == null) |
|||
continue; |
|||
|
|||
visual.StopAnimation("Translation"); |
|||
visual.Translation = default; |
|||
} |
|||
|
|||
_animationsStarted = false; |
|||
} |
|||
|
|||
private void RunHitTests() |
|||
{ |
|||
var width = Math.Max(1, _scene.Bounds.Width); |
|||
var height = Math.Max(1, _scene.Bounds.Height); |
|||
var baseIndex = _updateCount * 37; |
|||
|
|||
for (var i = 0; i < _hitTestsPerFrame; i++) |
|||
{ |
|||
_hitTestCount++; |
|||
var sample = baseIndex + (i * 97); |
|||
var point = new Point(sample * 17 % width, sample * 29 % height); |
|||
var hit = _scene.GetVisualAt(point); |
|||
|
|||
if (hit is Cell cell) |
|||
{ |
|||
SetLastHitCell(cell); |
|||
_hitCount++; |
|||
} |
|||
} |
|||
} |
|||
|
|||
private static Vector3 GetAnimationOffset(int index) |
|||
{ |
|||
var x = index % 4 switch |
|||
{ |
|||
0 => -AnimationTravel, |
|||
1 => AnimationTravel, |
|||
2 => -AnimationTravel / 2, |
|||
_ => AnimationTravel / 2 |
|||
}; |
|||
var y = index / 4 % 4 switch |
|||
{ |
|||
0 => -AnimationTravel, |
|||
1 => AnimationTravel, |
|||
2 => AnimationTravel / 2, |
|||
_ => -AnimationTravel / 2 |
|||
}; |
|||
|
|||
return new Vector3(x, y, 0); |
|||
} |
|||
|
|||
private void ResetState() |
|||
{ |
|||
StopAnimations(); |
|||
|
|||
_lastClickedCell?.ClearHighlight(); |
|||
_lastHitCell = null; |
|||
_lastClickedCell = null; |
|||
|
|||
_updateCount = 0; |
|||
_hitTestCount = 0; |
|||
_hitCount = 0; |
|||
_lastSecondUpdateCount = 0; |
|||
_lastSecondHitTestCount = 0; |
|||
_lastSecondHitCount = 0; |
|||
_lastSecondTime = default; |
|||
_lastSecondUpdatesPerSecond = 0; |
|||
_lastSecondHitTestsPerSecond = 0; |
|||
_lastSecondHitsPerSecond = 0; |
|||
_clickCount = 0; |
|||
_stopwatch.Restart(); |
|||
UpdateStats(); |
|||
} |
|||
|
|||
private void UpdateStats() |
|||
{ |
|||
var elapsed = _stopwatch.Elapsed; |
|||
var seconds = Math.Max(0.001, (elapsed - _lastSecondTime).TotalSeconds); |
|||
_lastSecondUpdatesPerSecond = (_updateCount - _lastSecondUpdateCount) / seconds; |
|||
_lastSecondHitTestsPerSecond = (_hitTestCount - _lastSecondHitTestCount) / seconds; |
|||
_lastSecondHitsPerSecond = (_hitCount - _lastSecondHitCount) / seconds; |
|||
_lastSecondUpdateCount = _updateCount; |
|||
_lastSecondHitTestCount = _hitTestCount; |
|||
_lastSecondHitCount = _hitCount; |
|||
_lastSecondTime = elapsed; |
|||
|
|||
_stats.Text = |
|||
$"Visuals: {_cells.Length} ({_cells.Length / 5} animated), " + |
|||
$"Hit tests/frame: {_hitTestsPerFrame}, " + |
|||
$"Composition updates/s: {_lastSecondUpdatesPerSecond:F1}, Hit tests/s: {_lastSecondHitTestsPerSecond:F0}, " + |
|||
$"Hits/s: {_lastSecondHitsPerSecond:F0}, Misses/s: {_lastSecondHitTestsPerSecond - _lastSecondHitsPerSecond:F0}, " + |
|||
$"Clicks: {_clickCount}"; |
|||
} |
|||
|
|||
private void OnCellPointerPressed(object? sender, PointerPressedEventArgs e) |
|||
{ |
|||
if (sender is not Cell cell) |
|||
return; |
|||
|
|||
SetLastClickedCell(cell); |
|||
_clickCount++; |
|||
e.Handled = true; |
|||
} |
|||
|
|||
private void SetLastHitCell(Cell cell) |
|||
{ |
|||
if (ReferenceEquals(_lastHitCell, cell)) |
|||
return; |
|||
|
|||
_lastHitCell = cell; |
|||
} |
|||
|
|||
private void SetLastClickedCell(Cell cell) |
|||
{ |
|||
if (!ReferenceEquals(_lastClickedCell, cell) && _lastClickedCell != null) |
|||
{ |
|||
_lastClickedCell.IsLatestClick = false; |
|||
_lastClickedCell.UpdateHighlight(); |
|||
} |
|||
|
|||
_lastClickedCell = cell; |
|||
cell.IsLatestClick = true; |
|||
cell.UpdateHighlight(); |
|||
} |
|||
|
|||
private static IBrush CreateBrush(int index) |
|||
{ |
|||
var r = (byte)(80 + (index * 47 % 160)); |
|||
var g = (byte)(80 + (index * 91 % 160)); |
|||
var b = (byte)(80 + (index * 137 % 160)); |
|||
return new SolidColorBrush(Color.FromRgb(r, g, b)); |
|||
} |
|||
|
|||
private sealed class Cell : Border |
|||
{ |
|||
public Cell(int index) |
|||
{ |
|||
Index = index; |
|||
BorderThickness = new Thickness(1); |
|||
} |
|||
|
|||
public int Index { get; } |
|||
public bool IsLatestClick { get; set; } |
|||
|
|||
public void ClearHighlight() |
|||
{ |
|||
IsLatestClick = false; |
|||
UpdateHighlight(); |
|||
} |
|||
|
|||
public void UpdateHighlight() |
|||
{ |
|||
BorderBrush = IsLatestClick ? Brushes.White : Brushes.Transparent; |
|||
ZIndex = IsLatestClick ? 1 : 0; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,894 @@ |
|||
using System; |
|||
using System.Buffers; |
|||
using System.Collections.Generic; |
|||
using System.Runtime.CompilerServices; |
|||
using System.Runtime.InteropServices; |
|||
using Avalonia.Collections.Pooled; |
|||
using Avalonia.Platform; |
|||
|
|||
namespace Avalonia.Rendering.Composition; |
|||
|
|||
internal sealed class CompositionHitTestAabbTree |
|||
{ |
|||
private const int Null = -1; |
|||
private const int OrderBucketSize = 32; |
|||
private const double FatBoundsPadding = 1; |
|||
private static readonly CandidateComparer s_candidateComparer = new(); |
|||
|
|||
private readonly CompositionVisualCollection _children; |
|||
private readonly Dictionary<CompositionVisual, Entry> _entries = []; |
|||
private readonly List<Bucket> _buckets = []; |
|||
private readonly List<Node> _nodes = []; |
|||
private int _freeList = Null; |
|||
|
|||
public CompositionHitTestAabbTree(CompositionVisualCollection children) |
|||
{ |
|||
_children = children; |
|||
|
|||
for (var i = 0; i < children.Count; i++) |
|||
Update(children[i], i); |
|||
} |
|||
|
|||
public void Clear() |
|||
{ |
|||
_entries.Clear(); |
|||
_buckets.Clear(); |
|||
_nodes.Clear(); |
|||
_freeList = Null; |
|||
} |
|||
|
|||
public void Update(CompositionVisual visual, int order) |
|||
{ |
|||
ref var entry = ref CollectionsMarshal.GetValueRefOrAddDefault(_entries, visual, out var exists); |
|||
if (!exists) |
|||
{ |
|||
var bucketIndex = GetBucketIndex(order); |
|||
entry = new Entry(order); |
|||
GetOrCreateBucket(bucketIndex); |
|||
} |
|||
else if (entry.Order != order) |
|||
{ |
|||
UpdateOrderCore(visual, ref entry, order); |
|||
} |
|||
|
|||
var state = GetBoundsState(visual, out var bounds, out var revision); |
|||
UpdateBounds(visual, ref entry, state, bounds, revision); |
|||
} |
|||
|
|||
public void Remove(CompositionVisual visual) |
|||
{ |
|||
if (!_entries.Remove(visual, out var entry)) |
|||
return; |
|||
|
|||
if (entry.Leaf != Null) |
|||
DestroyLeaf(entry.Leaf); |
|||
else if (entry.IsUnbounded) |
|||
RemoveUnbounded(visual, entry.Order); |
|||
|
|||
RemoveBucketIfEmpty(GetBucketIndex(entry.Order)); |
|||
} |
|||
|
|||
public void UpdateOrder(CompositionVisual visual, int order) |
|||
{ |
|||
ref var entry = ref CollectionsMarshal.GetValueRefOrAddDefault(_entries, visual, out var exists); |
|||
if (!exists) |
|||
{ |
|||
entry = new Entry(order); |
|||
return; |
|||
} |
|||
|
|||
if (entry.Order != order) |
|||
UpdateOrderCore(visual, ref entry, order); |
|||
} |
|||
|
|||
private void UpdateOrderCore(CompositionVisual visual, ref Entry entry, int order) |
|||
{ |
|||
var oldOrder = entry.Order; |
|||
var oldBucket = GetBucketIndex(oldOrder); |
|||
var newBucket = GetBucketIndex(order); |
|||
entry.Order = order; |
|||
|
|||
if (entry.Leaf != Null) |
|||
{ |
|||
MoveLeaf(entry.Leaf, order); |
|||
return; |
|||
} |
|||
|
|||
if (entry.IsUnbounded) |
|||
{ |
|||
MoveUnbounded(visual, oldOrder, order); |
|||
return; |
|||
} |
|||
|
|||
if (oldBucket != newBucket) |
|||
RemoveBucketIfEmpty(oldBucket); |
|||
} |
|||
|
|||
public void Query(Point point, PooledList<CompositionVisual> results, ulong readbackRevision) |
|||
{ |
|||
var candidates = ArrayPool<Candidate>.Shared.Rent(OrderBucketSize); |
|||
var stack = ArrayPool<int>.Shared.Rent(16); |
|||
var candidateCount = 0; |
|||
|
|||
try |
|||
{ |
|||
for (var i = _buckets.Count - 1; i >= 0; i--) |
|||
{ |
|||
UpdateBucket(i, readbackRevision); |
|||
|
|||
var bucket = _buckets[i]; |
|||
if (bucket.Root == Null && bucket.Unbounded is not { Count: > 0 }) |
|||
continue; |
|||
|
|||
candidateCount = 0; |
|||
var stackCount = 0; |
|||
QueryBucket(bucket, point, ref candidates, ref candidateCount, ref stack, ref stackCount); |
|||
candidates.AsSpan(0, candidateCount).Sort(s_candidateComparer); |
|||
|
|||
for (var j = 0; j < candidateCount; j++) |
|||
results.Add(candidates[j].Visual); |
|||
|
|||
candidates.AsSpan(0, candidateCount).Clear(); |
|||
} |
|||
} |
|||
finally |
|||
{ |
|||
candidates.AsSpan(0, candidateCount).Clear(); |
|||
ArrayPool<Candidate>.Shared.Return(candidates); |
|||
ArrayPool<int>.Shared.Return(stack); |
|||
} |
|||
} |
|||
|
|||
public CompositionVisual? QueryFirst(CompositionTarget target, Point point, Func<CompositionVisual, bool>? filter, Func<CompositionVisual, bool>? resultFilter, ulong readbackRevision) |
|||
{ |
|||
var candidates = ArrayPool<Candidate>.Shared.Rent(OrderBucketSize); |
|||
var stack = ArrayPool<int>.Shared.Rent(16); |
|||
var candidateCount = 0; |
|||
|
|||
try |
|||
{ |
|||
for (var i = _buckets.Count - 1; i >= 0; i--) |
|||
{ |
|||
UpdateBucket(i, readbackRevision); |
|||
|
|||
var bucket = _buckets[i]; |
|||
if (bucket.Root == Null && bucket.Unbounded is not { Count: > 0 }) |
|||
continue; |
|||
|
|||
candidateCount = 0; |
|||
var stackCount = 0; |
|||
QueryBucket(bucket, point, ref candidates, ref candidateCount, ref stack, ref stackCount); |
|||
candidates.AsSpan(0, candidateCount).Sort(s_candidateComparer); |
|||
|
|||
for (var j = 0; j < candidateCount; j++) |
|||
{ |
|||
var hit = target.HitTestFirstCore(candidates[j].Visual, point, filter, resultFilter); |
|||
if (hit != null) |
|||
return hit; |
|||
} |
|||
|
|||
candidates.AsSpan(0, candidateCount).Clear(); |
|||
} |
|||
} |
|||
finally |
|||
{ |
|||
candidates.AsSpan(0, candidateCount).Clear(); |
|||
ArrayPool<Candidate>.Shared.Return(candidates); |
|||
ArrayPool<int>.Shared.Return(stack); |
|||
} |
|||
|
|||
return null; |
|||
} |
|||
|
|||
private void UpdateBucket(int bucketIndex, ulong readbackRevision) |
|||
{ |
|||
ref var bucket = ref GetRef(_buckets, bucketIndex); |
|||
if (bucket.ReadbackRevision == readbackRevision) |
|||
return; |
|||
|
|||
var end = Math.Min(_children.Count, (bucketIndex + 1) * OrderBucketSize); |
|||
for (var i = bucketIndex * OrderBucketSize; i < end; i++) |
|||
{ |
|||
var visual = _children[i]; |
|||
ref var entry = ref CollectionsMarshal.GetValueRefOrNullRef(_entries, visual); |
|||
|
|||
var state = GetBoundsState(visual, out var bounds, out var revision); |
|||
if (entry.Revision != revision) |
|||
UpdateBounds(visual, ref entry, state, bounds, revision); |
|||
} |
|||
|
|||
bucket.ReadbackRevision = readbackRevision; |
|||
} |
|||
|
|||
private void UpdateBounds(CompositionVisual visual, ref Entry entry, BoundsState state, LtrbRect bounds, ulong revision) |
|||
{ |
|||
entry.Revision = revision; |
|||
|
|||
if (entry.Leaf != Null) |
|||
{ |
|||
if (state == BoundsState.Bounded) |
|||
{ |
|||
UpdateLeaf(entry.Leaf, bounds, entry.Order); |
|||
} |
|||
else |
|||
{ |
|||
DestroyLeaf(entry.Leaf); |
|||
entry.Leaf = Null; |
|||
if (state == BoundsState.Unbounded) |
|||
AddUnbounded(visual, entry.Order, ref entry); |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
if (entry.IsUnbounded) |
|||
{ |
|||
if (state == BoundsState.Unbounded) |
|||
return; |
|||
|
|||
RemoveUnbounded(visual, entry.Order); |
|||
entry.IsUnbounded = false; |
|||
|
|||
if (state == BoundsState.Bounded) |
|||
entry.Leaf = CreateLeaf(visual, bounds, entry.Order); |
|||
|
|||
return; |
|||
} |
|||
|
|||
if (state == BoundsState.Bounded) |
|||
entry.Leaf = CreateLeaf(visual, bounds, entry.Order); |
|||
else if (state == BoundsState.Unbounded) |
|||
AddUnbounded(visual, entry.Order, ref entry); |
|||
} |
|||
|
|||
private void QueryBucket(Bucket bucket, Point point, ref Candidate[] candidates, ref int candidateCount, ref int[] stack, ref int stackCount) |
|||
{ |
|||
PushQueryNode(ref stack, ref stackCount, bucket.Root); |
|||
|
|||
while (stackCount > 0) |
|||
{ |
|||
var nodeIndex = stack[--stackCount]; |
|||
var node = _nodes[nodeIndex]; |
|||
|
|||
if (!node.Bounds.Contains(point)) |
|||
continue; |
|||
|
|||
if (node.IsLeaf) |
|||
{ |
|||
if (node.Visual != null) |
|||
AddCandidate(ref candidates, ref candidateCount, new Candidate(node.Visual, node.Order)); |
|||
} |
|||
else |
|||
{ |
|||
PushQueryNode(ref stack, ref stackCount, node.Child1); |
|||
PushQueryNode(ref stack, ref stackCount, node.Child2); |
|||
} |
|||
} |
|||
|
|||
if (bucket.Unbounded != null) |
|||
foreach (var visual in bucket.Unbounded) |
|||
if (_entries.TryGetValue(visual, out var entry)) |
|||
AddCandidate(ref candidates, ref candidateCount, new Candidate(visual, entry.Order)); |
|||
} |
|||
|
|||
private static void AddCandidate(ref Candidate[] candidates, ref int count, Candidate candidate) |
|||
{ |
|||
if (count == candidates.Length) |
|||
Resize(ref candidates, count); |
|||
|
|||
candidates[count++] = candidate; |
|||
} |
|||
|
|||
private static void PushQueryNode(ref int[] stack, ref int count, int nodeIndex) |
|||
{ |
|||
if (nodeIndex == Null) |
|||
return; |
|||
|
|||
if (count == stack.Length) |
|||
Resize(ref stack, count); |
|||
|
|||
stack[count++] = nodeIndex; |
|||
} |
|||
|
|||
private static void Resize<T>(ref T[] buffer, int count) |
|||
{ |
|||
var resized = ArrayPool<T>.Shared.Rent(buffer.Length * 2); |
|||
buffer.AsSpan(0, count).CopyTo(resized); |
|||
ArrayPool<T>.Shared.Return(buffer, RuntimeHelpers.IsReferenceOrContainsReferences<T>()); |
|||
buffer = resized; |
|||
} |
|||
|
|||
private static int GetBucketIndex(int order) => order / OrderBucketSize; |
|||
|
|||
private ref Bucket GetOrCreateBucket(int bucketIndex) |
|||
{ |
|||
while (_buckets.Count <= bucketIndex) |
|||
_buckets.Add(new Bucket(Null)); |
|||
|
|||
return ref GetRef(_buckets, bucketIndex); |
|||
} |
|||
|
|||
private void RemoveBucketIfEmpty(int bucketIndex) |
|||
{ |
|||
if (bucketIndex >= _buckets.Count) |
|||
return; |
|||
|
|||
var lastRequiredBucketIndex = _children.Count == 0 ? Null : GetBucketIndex(_children.Count - 1); |
|||
bool removeTrailingBucket; |
|||
{ |
|||
ref var bucket = ref GetRef(_buckets, bucketIndex); |
|||
if (bucket.Unbounded?.Count == 0) |
|||
bucket.Unbounded = null; |
|||
|
|||
removeTrailingBucket = bucket.IsEmpty && |
|||
bucketIndex == _buckets.Count - 1 && |
|||
bucketIndex > lastRequiredBucketIndex; |
|||
} |
|||
|
|||
if (!removeTrailingBucket) |
|||
return; |
|||
|
|||
do |
|||
{ |
|||
_buckets.RemoveAt(_buckets.Count - 1); |
|||
} while (_buckets.Count > 0 && |
|||
_buckets.Count - 1 > lastRequiredBucketIndex && |
|||
_buckets[^1].IsEmpty); |
|||
} |
|||
|
|||
private static ref T GetRef<T>(List<T> items, int index) => ref CollectionsMarshal.AsSpan(items)[index]; |
|||
|
|||
private int CreateLeaf(CompositionVisual visual, LtrbRect bounds, int order) |
|||
{ |
|||
var leaf = AllocateNode(); |
|||
{ |
|||
ref var node = ref GetRef(_nodes, leaf); |
|||
node.Bounds = Fatten(bounds); |
|||
node.Visual = visual; |
|||
node.Order = order; |
|||
node.Bucket = GetBucketIndex(order); |
|||
node.Height = 0; |
|||
} |
|||
|
|||
InsertLeaf(leaf); |
|||
return leaf; |
|||
} |
|||
|
|||
private void DestroyLeaf(int leaf) |
|||
{ |
|||
RemoveLeaf(leaf); |
|||
FreeNode(leaf); |
|||
} |
|||
|
|||
private void UpdateLeaf(int leaf, LtrbRect bounds, int order) |
|||
{ |
|||
var bucket = GetBucketIndex(order); |
|||
|
|||
{ |
|||
ref var node = ref GetRef(_nodes, leaf); |
|||
|
|||
// If the exact bounds still fit inside the fat bounds, the tree shape can stay unchanged.
|
|||
if (node.Bucket == bucket && node.Bounds.Contains(bounds)) |
|||
{ |
|||
node.Order = order; |
|||
return; |
|||
} |
|||
} |
|||
|
|||
RemoveLeaf(leaf); |
|||
|
|||
{ |
|||
ref var removedNode = ref GetRef(_nodes, leaf); |
|||
removedNode.Bounds = Fatten(bounds); |
|||
removedNode.Bucket = bucket; |
|||
removedNode.Order = order; |
|||
} |
|||
|
|||
InsertLeaf(leaf); |
|||
} |
|||
|
|||
private void MoveLeaf(int leaf, int order) |
|||
{ |
|||
var bucket = GetBucketIndex(order); |
|||
|
|||
{ |
|||
ref var node = ref GetRef(_nodes, leaf); |
|||
if (node.Bucket == bucket) |
|||
{ |
|||
node.Order = order; |
|||
return; |
|||
} |
|||
} |
|||
|
|||
RemoveLeaf(leaf); |
|||
|
|||
{ |
|||
ref var removedNode = ref GetRef(_nodes, leaf); |
|||
removedNode.Order = order; |
|||
removedNode.Bucket = bucket; |
|||
} |
|||
|
|||
InsertLeaf(leaf); |
|||
} |
|||
|
|||
private int AllocateNode() |
|||
{ |
|||
if (_freeList == Null) |
|||
{ |
|||
_nodes.Add(new Node |
|||
{ |
|||
Parent = Null, |
|||
Child1 = Null, |
|||
Child2 = Null, |
|||
Next = Null |
|||
}); |
|||
return _nodes.Count - 1; |
|||
} |
|||
|
|||
var index = _freeList; |
|||
ref var node = ref GetRef(_nodes, index); |
|||
_freeList = node.Next; |
|||
node.Parent = Null; |
|||
node.Child1 = Null; |
|||
node.Child2 = Null; |
|||
node.Next = Null; |
|||
node.Height = 0; |
|||
node.Visual = null; |
|||
node.Order = 0; |
|||
node.Bucket = 0; |
|||
return index; |
|||
} |
|||
|
|||
private void FreeNode(int index) |
|||
{ |
|||
ref var node = ref GetRef(_nodes, index); |
|||
node.Next = _freeList; |
|||
node.Parent = Null; |
|||
node.Child1 = Null; |
|||
node.Child2 = Null; |
|||
node.Height = -1; |
|||
node.Visual = null; |
|||
node.Order = 0; |
|||
node.Bucket = 0; |
|||
_freeList = index; |
|||
} |
|||
|
|||
private void InsertLeaf(int leaf) |
|||
{ |
|||
var bucketIndex = GetRef(_nodes, leaf).Bucket; |
|||
ref var bucket = ref GetOrCreateBucket(bucketIndex); |
|||
|
|||
if (bucket.Root == Null) |
|||
{ |
|||
bucket.Root = leaf; |
|||
ref var root = ref GetRef(_nodes, leaf); |
|||
root.Parent = Null; |
|||
return; |
|||
} |
|||
|
|||
var leafBounds = GetRef(_nodes, leaf).Bounds; |
|||
var sibling = FindBestSibling(bucket.Root, leafBounds); |
|||
var oldParent = GetRef(_nodes, sibling).Parent; |
|||
var newParent = AllocateNode(); |
|||
|
|||
// Insert by replacing the chosen sibling with a new internal parent:
|
|||
//
|
|||
// Before: oldParent After: oldParent
|
|||
// | |
|
|||
// sibling newParent
|
|||
// / \
|
|||
// sibling leaf
|
|||
ref var parentNode = ref GetRef(_nodes, newParent); |
|||
parentNode.Parent = oldParent; |
|||
parentNode.Bounds = leafBounds.Union(GetRef(_nodes, sibling).Bounds); |
|||
parentNode.Height = GetRef(_nodes, sibling).Height + 1; |
|||
parentNode.Child1 = sibling; |
|||
parentNode.Child2 = leaf; |
|||
parentNode.Visual = null; |
|||
parentNode.Bucket = bucketIndex; |
|||
|
|||
ref var siblingNode = ref GetRef(_nodes, sibling); |
|||
siblingNode.Parent = newParent; |
|||
|
|||
ref var leafNode = ref GetRef(_nodes, leaf); |
|||
leafNode.Parent = newParent; |
|||
|
|||
if (oldParent == Null) |
|||
{ |
|||
bucket.Root = newParent; |
|||
} |
|||
else |
|||
{ |
|||
ref var oldParentNode = ref GetRef(_nodes, oldParent); |
|||
if (oldParentNode.Child1 == sibling) |
|||
oldParentNode.Child1 = newParent; |
|||
else |
|||
oldParentNode.Child2 = newParent; |
|||
} |
|||
|
|||
FixAncestors(newParent); |
|||
} |
|||
|
|||
private int FindBestSibling(int root, LtrbRect leafBounds) |
|||
{ |
|||
var index = root; |
|||
while (!_nodes[index].IsLeaf) |
|||
{ |
|||
var node = _nodes[index]; |
|||
var child1 = node.Child1; |
|||
var child2 = node.Child2; |
|||
var area = Perimeter(node.Bounds); |
|||
var combinedArea = Perimeter(node.Bounds.Union(leafBounds)); |
|||
var cost = 2 * combinedArea; |
|||
var inheritanceCost = 2 * (combinedArea - area); |
|||
|
|||
var cost1 = GetInsertionCost(child1, leafBounds, inheritanceCost); |
|||
var cost2 = GetInsertionCost(child2, leafBounds, inheritanceCost); |
|||
|
|||
// Stop descending when pairing with this internal node is already cheaper.
|
|||
if (cost < cost1 && cost < cost2) |
|||
break; |
|||
|
|||
index = cost1 < cost2 ? child1 : child2; |
|||
} |
|||
|
|||
return index; |
|||
} |
|||
|
|||
private double GetInsertionCost(int nodeIndex, LtrbRect leafBounds, double inheritanceCost) |
|||
{ |
|||
var node = _nodes[nodeIndex]; |
|||
var union = node.Bounds.Union(leafBounds); |
|||
|
|||
if (node.IsLeaf) |
|||
return Perimeter(union) + inheritanceCost; |
|||
|
|||
return Perimeter(union) - Perimeter(node.Bounds) + inheritanceCost; |
|||
} |
|||
|
|||
private void RemoveLeaf(int leaf) |
|||
{ |
|||
var bucketIndex = GetRef(_nodes, leaf).Bucket; |
|||
var removedRoot = false; |
|||
{ |
|||
ref var bucket = ref GetRef(_buckets, bucketIndex); |
|||
if (leaf == bucket.Root) |
|||
{ |
|||
bucket.Root = Null; |
|||
removedRoot = true; |
|||
} |
|||
} |
|||
|
|||
if (removedRoot) |
|||
{ |
|||
RemoveBucketIfEmpty(bucketIndex); |
|||
return; |
|||
} |
|||
|
|||
var parent = GetRef(_nodes, leaf).Parent; |
|||
var parentNode = GetRef(_nodes, parent); |
|||
var grandParent = parentNode.Parent; |
|||
var sibling = parentNode.Child1 == leaf ? parentNode.Child2 : parentNode.Child1; |
|||
|
|||
// Collapse the removed leaf's parent and promote the sibling.
|
|||
if (grandParent != Null) |
|||
{ |
|||
// Before: grandParent After: grandParent
|
|||
// | |
|
|||
// parent sibling
|
|||
// / \
|
|||
// leaf sibling
|
|||
ref var grandParentNode = ref GetRef(_nodes, grandParent); |
|||
if (grandParentNode.Child1 == parent) |
|||
grandParentNode.Child1 = sibling; |
|||
else |
|||
grandParentNode.Child2 = sibling; |
|||
|
|||
ref var siblingNode = ref GetRef(_nodes, sibling); |
|||
siblingNode.Parent = grandParent; |
|||
|
|||
FreeNode(parent); |
|||
FixAncestors(grandParent); |
|||
} |
|||
else |
|||
{ |
|||
// If the parent was the root, the sibling becomes the new root.
|
|||
//
|
|||
// Before: parent(root) After: sibling(root)
|
|||
// / \
|
|||
// leaf sibling
|
|||
{ |
|||
ref var bucket = ref GetRef(_buckets, bucketIndex); |
|||
bucket.Root = sibling; |
|||
} |
|||
|
|||
ref var siblingNode = ref GetRef(_nodes, sibling); |
|||
siblingNode.Parent = Null; |
|||
FreeNode(parent); |
|||
} |
|||
|
|||
{ |
|||
ref var leafNode = ref GetRef(_nodes, leaf); |
|||
leafNode.Parent = Null; |
|||
} |
|||
|
|||
RemoveBucketIfEmpty(bucketIndex); |
|||
} |
|||
|
|||
private void FixAncestors(int index) |
|||
{ |
|||
while (index != Null) |
|||
{ |
|||
index = Balance(index); |
|||
|
|||
ref var node = ref GetRef(_nodes, index); |
|||
var child1 = GetRef(_nodes, node.Child1); |
|||
var child2 = GetRef(_nodes, node.Child2); |
|||
|
|||
// Ancestor bounds always cover both children after insert/remove/rotate.
|
|||
node.Bounds = child1.Bounds.Union(child2.Bounds); |
|||
node.Height = 1 + Math.Max(child1.Height, child2.Height); |
|||
|
|||
index = node.Parent; |
|||
} |
|||
} |
|||
|
|||
private int Balance(int indexA) |
|||
{ |
|||
var a = GetRef(_nodes, indexA); |
|||
if (a.IsLeaf || a.Height < 2) |
|||
return indexA; |
|||
|
|||
var indexB = a.Child1; |
|||
var indexC = a.Child2; |
|||
var b = GetRef(_nodes, indexB); |
|||
var c = GetRef(_nodes, indexC); |
|||
var balance = c.Height - b.Height; |
|||
|
|||
// The right subtree is heavier than the left. Rotate C up.
|
|||
if (balance > 1) |
|||
return RotateCUp(indexA, indexB, indexC); |
|||
|
|||
// The left subtree is heavier than the right. Rotate B up.
|
|||
if (balance < -1) |
|||
return RotateBUp(indexA, indexB, indexC); |
|||
|
|||
return indexA; |
|||
} |
|||
|
|||
private int RotateCUp(int indexA, int indexB, int indexC) |
|||
{ |
|||
// Rotate C above A:
|
|||
//
|
|||
// Before: A After, if F taller: C
|
|||
// / \ / \
|
|||
// B C A F
|
|||
// / \ / \
|
|||
// F G B G
|
|||
//
|
|||
// After, otherwise: C
|
|||
// / \
|
|||
// A G
|
|||
// / \
|
|||
// B F
|
|||
ref var a = ref GetRef(_nodes, indexA); |
|||
ref var c = ref GetRef(_nodes, indexC); |
|||
var indexF = c.Child1; |
|||
var indexG = c.Child2; |
|||
ref var f = ref GetRef(_nodes, indexF); |
|||
ref var g = ref GetRef(_nodes, indexG); |
|||
|
|||
c.Child1 = indexA; |
|||
c.Parent = a.Parent; |
|||
a.Parent = indexC; |
|||
|
|||
// C takes A's old place in the parent chain.
|
|||
ReplaceParentChild(indexA, indexC, c.Parent); |
|||
|
|||
// Keep the taller C child with C, and move the other child under A.
|
|||
if (f.Height > g.Height) |
|||
{ |
|||
c.Child2 = indexF; |
|||
a.Child2 = indexG; |
|||
g.Parent = indexA; |
|||
a.Bounds = GetRef(_nodes, indexB).Bounds.Union(g.Bounds); |
|||
c.Bounds = a.Bounds.Union(f.Bounds); |
|||
a.Height = 1 + Math.Max(GetRef(_nodes, indexB).Height, g.Height); |
|||
c.Height = 1 + Math.Max(a.Height, f.Height); |
|||
} |
|||
else |
|||
{ |
|||
c.Child2 = indexG; |
|||
a.Child2 = indexF; |
|||
f.Parent = indexA; |
|||
a.Bounds = GetRef(_nodes, indexB).Bounds.Union(f.Bounds); |
|||
c.Bounds = a.Bounds.Union(g.Bounds); |
|||
a.Height = 1 + Math.Max(GetRef(_nodes, indexB).Height, f.Height); |
|||
c.Height = 1 + Math.Max(a.Height, g.Height); |
|||
} |
|||
|
|||
return indexC; |
|||
} |
|||
|
|||
private int RotateBUp(int indexA, int indexB, int indexC) |
|||
{ |
|||
// Rotate B above A:
|
|||
//
|
|||
// Before: A After, if D taller: B
|
|||
// / \ / \
|
|||
// B C A D
|
|||
// / \ / \
|
|||
// D E E C
|
|||
//
|
|||
// After, otherwise: B
|
|||
// / \
|
|||
// A E
|
|||
// / \
|
|||
// D C
|
|||
ref var a = ref GetRef(_nodes, indexA); |
|||
ref var b = ref GetRef(_nodes, indexB); |
|||
var indexD = b.Child1; |
|||
var indexE = b.Child2; |
|||
ref var d = ref GetRef(_nodes, indexD); |
|||
ref var e = ref GetRef(_nodes, indexE); |
|||
|
|||
b.Child1 = indexA; |
|||
b.Parent = a.Parent; |
|||
a.Parent = indexB; |
|||
|
|||
// B takes A's old place in the parent chain.
|
|||
ReplaceParentChild(indexA, indexB, b.Parent); |
|||
|
|||
// Keep the taller B child with B, and move the other child under A.
|
|||
if (d.Height > e.Height) |
|||
{ |
|||
b.Child2 = indexD; |
|||
a.Child1 = indexE; |
|||
e.Parent = indexA; |
|||
a.Bounds = GetRef(_nodes, indexC).Bounds.Union(e.Bounds); |
|||
b.Bounds = a.Bounds.Union(d.Bounds); |
|||
a.Height = 1 + Math.Max(GetRef(_nodes, indexC).Height, e.Height); |
|||
b.Height = 1 + Math.Max(a.Height, d.Height); |
|||
} |
|||
else |
|||
{ |
|||
b.Child2 = indexE; |
|||
a.Child1 = indexD; |
|||
d.Parent = indexA; |
|||
a.Bounds = GetRef(_nodes, indexC).Bounds.Union(d.Bounds); |
|||
b.Bounds = a.Bounds.Union(e.Bounds); |
|||
a.Height = 1 + Math.Max(GetRef(_nodes, indexC).Height, d.Height); |
|||
b.Height = 1 + Math.Max(a.Height, e.Height); |
|||
} |
|||
|
|||
return indexB; |
|||
} |
|||
|
|||
private void ReplaceParentChild(int oldChild, int newChild, int parent) |
|||
{ |
|||
if (parent == Null) |
|||
{ |
|||
ref var bucket = ref GetRef(_buckets, GetRef(_nodes, newChild).Bucket); |
|||
bucket.Root = newChild; |
|||
return; |
|||
} |
|||
|
|||
ref var parentNode = ref GetRef(_nodes, parent); |
|||
if (parentNode.Child1 == oldChild) |
|||
parentNode.Child1 = newChild; |
|||
else |
|||
parentNode.Child2 = newChild; |
|||
} |
|||
|
|||
private void AddUnbounded(CompositionVisual visual, int order, ref Entry entry) |
|||
{ |
|||
var bucketIndex = GetBucketIndex(order); |
|||
ref var bucket = ref GetOrCreateBucket(bucketIndex); |
|||
(bucket.Unbounded ??= []).Add(visual); |
|||
entry.IsUnbounded = true; |
|||
} |
|||
|
|||
private void MoveUnbounded(CompositionVisual visual, int oldOrder, int order) |
|||
{ |
|||
var oldBucketIndex = GetBucketIndex(oldOrder); |
|||
var newBucketIndex = GetBucketIndex(order); |
|||
|
|||
if (oldBucketIndex == newBucketIndex) |
|||
return; |
|||
|
|||
RemoveUnbounded(visual, oldOrder); |
|||
ref var newBucket = ref GetOrCreateBucket(newBucketIndex); |
|||
(newBucket.Unbounded ??= []).Add(visual); |
|||
} |
|||
|
|||
private void RemoveUnbounded(CompositionVisual visual, int order) |
|||
{ |
|||
var bucketIndex = GetBucketIndex(order); |
|||
{ |
|||
ref var bucket = ref GetRef(_buckets, bucketIndex); |
|||
bucket.Unbounded!.Remove(visual); |
|||
} |
|||
|
|||
RemoveBucketIfEmpty(bucketIndex); |
|||
} |
|||
|
|||
private static BoundsState GetBoundsState(CompositionVisual visual, out LtrbRect bounds, out ulong revision) |
|||
{ |
|||
bounds = default; |
|||
revision = 0; |
|||
|
|||
var readback = visual.TryGetValidReadback(); |
|||
if (readback == null) |
|||
return BoundsState.Empty; |
|||
revision = readback.Revision; |
|||
|
|||
if (visual.DisableSubTreeBoundsHitTestOptimization) |
|||
return BoundsState.Unbounded; |
|||
|
|||
if (readback.TransformedSubtreeBounds is not { } subtreeBounds || subtreeBounds.IsZeroSize) |
|||
return BoundsState.Empty; |
|||
|
|||
bounds = subtreeBounds; |
|||
return BoundsState.Bounded; |
|||
} |
|||
|
|||
// Fatten the bounds by a small amount to avoid having to update the tree for every tiny movement.
|
|||
private static LtrbRect Fatten(LtrbRect bounds) => |
|||
new(bounds.Left - FatBoundsPadding, |
|||
bounds.Top - FatBoundsPadding, |
|||
bounds.Right + FatBoundsPadding, |
|||
bounds.Bottom + FatBoundsPadding); |
|||
|
|||
private static double Perimeter(LtrbRect bounds) => 2 * (bounds.Width + bounds.Height); |
|||
|
|||
private enum BoundsState |
|||
{ |
|||
Empty, |
|||
Bounded, |
|||
Unbounded |
|||
} |
|||
|
|||
private struct Node |
|||
{ |
|||
public LtrbRect Bounds; |
|||
public CompositionVisual? Visual; |
|||
public int Parent; |
|||
public int Child1; |
|||
public int Child2; |
|||
public int Next; |
|||
public int Height; |
|||
public int Order; |
|||
public int Bucket; |
|||
|
|||
public readonly bool IsLeaf => Child1 == Null; |
|||
} |
|||
|
|||
private struct Bucket(int root) |
|||
{ |
|||
public int Root = root; |
|||
public List<CompositionVisual>? Unbounded = null; |
|||
public ulong ReadbackRevision; |
|||
|
|||
public readonly bool IsEmpty => Root == Null && (Unbounded == null || Unbounded.Count == 0); |
|||
} |
|||
|
|||
private struct Entry(int order) |
|||
{ |
|||
public int Order = order; |
|||
public int Leaf = Null; |
|||
public ulong Revision; |
|||
public bool IsUnbounded; |
|||
} |
|||
|
|||
private readonly struct Candidate(CompositionVisual visual, int order) |
|||
{ |
|||
public CompositionVisual Visual { get; } = visual; |
|||
public int Order { get; } = order; |
|||
} |
|||
|
|||
private sealed class CandidateComparer : IComparer<Candidate> |
|||
{ |
|||
// Higher child order is topmost, sort descending.
|
|||
public int Compare(Candidate left, Candidate right) => right.Order.CompareTo(left.Order); |
|||
} |
|||
} |
|||
Loading…
Reference in new issue