RefreshQueue.cs

using System.Drawing;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.SkiaSharp;
 
namespace Gondwana.Rendering;
 
internal sealed class RefreshQueue
{
    private readonly Func<bool> _isEnabled;
    private readonly List<Rectangle> _worldRects;   // World-space dirty regions (pixels)
    private readonly object _syncRoot = new();      // Guards _worldRects for cross-thread access
 
    internal RefreshQueue(Func<bool> isEnabled)
    {
        _isEnabled = isEnabled ?? throw new ArgumentNullException(nameof(isEnabled));
        _worldRects = new List<Rectangle>(64);
    }

    internal bool IsDirty
    {
        get { lock (_syncRoot) return _worldRects.Count > 0; }
    }

    internal IReadOnlyList<Rectangle> WorldRects => _worldRects;

    internal Rectangle[] SnapshotWorldRects()
    {
        lock (_syncRoot) return _worldRects.ToArray();
    }

    internal void AddWorldRect(Rectangle worldPixelRange)
    {
        if (!_isEnabled() || worldPixelRange.IsEmpty)
            return;
 
        // ensure we're on the engine thread
        var engine = Engine.Instance;
        if (!engine.EngineDispatcher.IsOnEngineThread)
        {
            engine.EngineDispatcher.Post(() => AddWorldRect(worldPixelRange));
            return;
        }
 
        lock (_syncRoot)
        {
            // Fast containment check: if any existing rect already fully contains this one, skip storing it.
            for (int i = 0; i < _worldRects.Count; i++)
            {
                if (_worldRects[i].Contains(worldPixelRange))
                    return;
            }
 
            _worldRects.Add(worldPixelRange);
        }
    }
 
    internal void AddViewScreenRect(View view, SceneLayer sceneLayer, Rectangle screenPixelRange)
    {
        if (!_isEnabled() || screenPixelRange.IsEmpty)
            return;
 
        if (view is null)
            throw new ArgumentNullException(nameof(view));
 
        if (sceneLayer is null)
            throw new ArgumentNullException(nameof(sceneLayer));
 
        // ensure we're on the engine thread
        var engine = Engine.Instance;
        if (!engine.EngineDispatcher.IsOnEngineThread)
        {
            engine.EngineDispatcher.Post(() => AddViewScreenRect(view, sceneLayer, screenPixelRange));
            return;
        }
 
        // clamp screenPixelRange to view's viewport
        screenPixelRange.Intersect(view.Viewport.TargetRectPx);
 
        var worldRect = view.ScreenRectToWorldRect(sceneLayer, screenPixelRange);
        worldRect.Inflate(3, 3); // Expand by 1 pixel in all directions to account for rounding errors.
        AddWorldRect(worldRect.ToPixelAlignedRect());
    }
 
    internal void ClearRefreshQueue()
    {
        // ensure we're on the engine thread
        var engine = Engine.Instance;
        if (!engine.EngineDispatcher.IsOnEngineThread)
        {
            engine.EngineDispatcher.Post(() => ClearRefreshQueue());
            return;
        }
 
        lock (_syncRoot)
            _worldRects.Clear();
    }
}