ViewManager.cs

using System.Collections.ObjectModel;
using System.Drawing;
using Gondwana.Scenes;
 
namespace Gondwana.Rendering.Views;

public sealed class ViewManager
{
    private readonly RenderSurfaceHostBase _renderSurfaceHost;
    private readonly List<View> _views = new();

    public event Action<View>? ViewAdded;

    public event Action<View>? ViewRemoved;
 
    private ViewManager() { }
 
    internal ViewManager(RenderSurfaceHostBase renderSurfaceHost)
    {
        _renderSurfaceHost = renderSurfaceHost;
    }

    public ReadOnlyCollection<View> Views => _views.AsReadOnly();

    public void AddView(Rectangle targetRectPx, float zoom = 1f, int zOrder = 0, RectangleF? worldBoundsPx = null)
    {
        if (worldBoundsPx is null)
            worldBoundsPx = RectangleF.Empty;
 
        var cam = new Camera(_renderSurfaceHost.Scene)
        {
            // clamp camera to Scene pixel bounds
            WorldBoundsPx = worldBoundsPx.Value,
            FollowLerpPerSecond = 0f // snap by default
        };
 
        cam.SnapTo(new PointF(0, 0));
 
        var vp = new Viewport
        {
            TargetRectPx = targetRectPx,
            Zoom = zoom
        };
 
        var view = new View(cam, vp) { ZOrder = zOrder };
        view.Viewport.TargetRectChanged += OnViewportTargetRectChanged;
        view.Viewport.ZoomChanged += OnViewportZoomChanged;
 
        _views.Add(view);
        _renderSurfaceHost.Scene.FullRefreshNeeded = true;
 
        SortViews();
 
        ViewAdded?.Invoke(view);
    }

    public void ConfigureSingleFullView(float zoom = 1f, int zOrder = 0)
    {
        if (_renderSurfaceHost.RenderSurfaceAdapter is null)
            throw new InvalidOperationException("RenderSurfaceAdapter is not available.");
 
        ClearViews();
 
        var backbuffer = _renderSurfaceHost.Backbuffer;
        var bounds = new Rectangle(0, 0, backbuffer.Width, backbuffer.Height);
 
        RectangleF worldBoundsPx = RectangleF.Empty;
        if (_renderSurfaceHost.Scene is not null)
            worldBoundsPx = _renderSurfaceHost.Scene.GetWorldBoundsPx();
 
        AddView(bounds, zoom, zOrder, worldBoundsPx);
    }

    public void ConfigureVerticalSplit(float leftZoom = 1f, float rightZoom = 1f)
    {
        if (_renderSurfaceHost.RenderSurfaceAdapter is null)
            throw new InvalidOperationException("RenderSurfaceAdapter is not available.");
 
        ClearViews();
 
        var backbuffer = _renderSurfaceHost.Backbuffer;
        int width = backbuffer.Width;
        int height = backbuffer.Height;
 
        int halfWidth = width / 2;
 
        RectangleF worldBoundsPx = RectangleF.Empty;
        if (_renderSurfaceHost.Scene is not null)
            worldBoundsPx = _renderSurfaceHost.Scene.GetWorldBoundsPx();
 
        // Left view
        AddView(
            new Rectangle(0, 0, halfWidth, height),
            leftZoom,
            zOrder: 0,
            worldBoundsPx: worldBoundsPx);
 
        // Right view
        AddView(
            new Rectangle(halfWidth, 0, width - halfWidth, height),
            rightZoom,
            zOrder: 1,
            worldBoundsPx: worldBoundsPx);
    }

    public void ConfigureHorizontalSplit(float topZoom = 1f, float bottomZoom = 1f)
    {
        if (_renderSurfaceHost.RenderSurfaceAdapter is null)
            throw new InvalidOperationException("RenderSurfaceAdapter is not available.");
 
        ClearViews();
 
        var backbuffer = _renderSurfaceHost.Backbuffer;
        int width = backbuffer.Width;
        int height = backbuffer.Height;
 
        int halfHeight = height / 2;
 
        RectangleF worldBoundsPx = RectangleF.Empty;
        if (_renderSurfaceHost.Scene is not null)
            worldBoundsPx = _renderSurfaceHost.Scene.GetWorldBoundsPx();
 
        // Top view
        AddView(
            new Rectangle(0, 0, width, halfHeight),
            topZoom,
            zOrder: 0,
            worldBoundsPx: worldBoundsPx);
 
        // Bottom view
        AddView(
            new Rectangle(0, halfHeight, width, height - halfHeight),
            bottomZoom,
            zOrder: 1,
            worldBoundsPx: worldBoundsPx);
    }

    public void ClearViews()
    {
        foreach (var view in _views!)
        {
            view.Viewport.TargetRectChanged -= OnViewportTargetRectChanged;
            view.Viewport.ZoomChanged -= OnViewportZoomChanged;
            ViewRemoved?.Invoke(view);
        }
 
        _views.Clear();
 
        if (_renderSurfaceHost.Scene is not null)
            _renderSurfaceHost.Scene.FullRefreshNeeded = true;
    }

    public IReadOnlyList<View> GetViewsBelow(View view)
    {
        int idx = _views.IndexOf(view);
        if (idx <= 0)
            return Array.Empty<View>();
 
        // views with lower Z (earlier in sorted list)
        return _views.GetRange(0, idx);
    }

    public IReadOnlyList<View> GetViewsAbove(View view)
    {
        int idx = _views.IndexOf(view);
        if (idx < 0 || idx >= _views.Count - 1)
            return Array.Empty<View>();
 
        // views with higher Z (later in sorted list)
        return _views.GetRange(idx + 1, _views.Count - (idx + 1));
    }
 
    #region internal methods
 
    internal void UpdateCameras(float dtSeconds)
    {
        foreach (var view in _views)
            view.Update(dtSeconds);
    }
 
    internal void BindToScene(Scene scene, bool limitCameraToWorldBoundPx)
    {
        RectangleF worldBoundsPx = limitCameraToWorldBoundPx ? scene.GetWorldBoundsPx() : RectangleF.Empty;
 
        // if no views exist, create a default one
        if (!_views.Any())
        {
            AddView(new Rectangle(0, 0, _renderSurfaceHost.Backbuffer.Width, _renderSurfaceHost.Backbuffer.Height), 1, 0, worldBoundsPx);
        }
        else
        {
            foreach (var view in _views)
            {
                view.Camera.WorldBoundsPx = worldBoundsPx;
            }
        }
    }
 
    #endregion internal methods
 
    #region private methods
 
    private void OnViewportZoomChanged(ViewportZoomChangedEventArgs args)
    {
        if (_renderSurfaceHost.Scene is not null)
            _renderSurfaceHost.Scene.FullRefreshNeeded = true;
    }
 
    private void OnViewportTargetRectChanged(ViewportResizedEventArgs args)
    {
        if (_renderSurfaceHost.Scene is not null)
            _renderSurfaceHost.Scene.FullRefreshNeeded = true;
    }
 
    private void SortViews()
    {
        _views.Sort(static (a, b) =>
        {
            int cmp = a.ZOrder.CompareTo(b.ZOrder);
 
            if (cmp != 0)
                return cmp;
 
            // deterministic tie-breaker
            return a.Id.CompareTo(b.Id);
        });
    }
 
    #endregion private methods
}