Viewport.cs

using System.Drawing;
 
namespace Gondwana.Rendering.Views;

public sealed class Viewport
{
    private Rectangle _targetRectPx = new Rectangle(0, 0, 1280, 720);
    private float _zoom = 1f;
    private float? _zoomTarget;
    private float _zoomLerpPerSecond;
    private float? _zoomDurationSeconds;
    private float _zoomElapsedSeconds;
    private float _zoomStart;

    public event Action<ViewportResizedEventArgs>? TargetRectChanged;

    public event Action<ViewportZoomChangedEventArgs>? ZoomChanged;

    public Rectangle TargetRectPx
    {
        get => _targetRectPx;
        set
        {
            if (value == _targetRectPx)
                return;
 
            var oldRect = _targetRectPx;
            _targetRectPx = value;
            TargetRectChanged?.Invoke(new ViewportResizedEventArgs(this, oldRect, value));
        }
    }

    public void Resize(int width, int height)
    {
        var rect = TargetRectPx;
        TargetRectPx = new Rectangle(rect.Left, rect.Top, width, height);
    }

    public float Zoom
    {
        get => _zoom;
        set
        {
            if (Math.Abs(value - _zoom) < 1e-6f)
                return;
 
            var oldZoom = _zoom;
            _zoom = value;
            ZoomChanged?.Invoke(new ViewportZoomChangedEventArgs(this, oldZoom, value));
        }
    }

    public PointF ScreenOffsetPx { get; set; } = PointF.Empty;

    public SizeF VisibleWorldSizePx => new SizeF(TargetRectPx.Width / Zoom, TargetRectPx.Height / Zoom);

    internal bool IsZoomAnimating => _zoomTarget is not null;
 
    #region zoom zoom

    public void SnapZoom(float zoom)
    {
        _zoomTarget = null;
        _zoomLerpPerSecond = 0f;
        _zoomDurationSeconds = null;
        _zoomElapsedSeconds = 0f;
        _zoomStart = zoom;
 
        Zoom = zoom;
    }

    public void ZoomTo(float targetZoom, float lerpPerSecond)
    {
        if (lerpPerSecond <= 0f)
        {
            SnapZoom(targetZoom);
            return;
        }
 
        _zoomStart = _zoom;
        _zoomTarget = targetZoom;
        _zoomLerpPerSecond = lerpPerSecond;
        _zoomDurationSeconds = null;
        _zoomElapsedSeconds = 0f;
    }

    public void ZoomToOverDuration(float targetZoom, float durationSeconds)
    {
        if (durationSeconds <= 0f)
        {
            SnapZoom(targetZoom);
            return;
        }
 
        _zoomStart = _zoom;
        _zoomTarget = targetZoom;
 
        _zoomDurationSeconds = durationSeconds;
        _zoomElapsedSeconds = 0f;
 
        // The fixed-duration path calculates progress directly.
        _zoomLerpPerSecond = 0f;
    }

    internal void UpdateZoom(float dtSeconds)
    {
        if (_zoomTarget is null)
            return;
 
        float target = _zoomTarget.Value;
        float dt = Math.Max(0f, dtSeconds);
 
        if (_zoomDurationSeconds is { } durationSeconds)
        {
            _zoomElapsedSeconds = Math.Min(_zoomElapsedSeconds + dt, durationSeconds);
 
            float progress = durationSeconds > 0f ? _zoomElapsedSeconds / durationSeconds : 1f;
 
            // Preserve the existing exponential ease-out character, but normalize
            // it so progress reaches exactly 1 at the requested duration.
            const float decay = 4.605170186f; // -ln(0.01)
 
            float normalization = 1f - MathF.Exp(-decay);
            float easedProgress = (1f - MathF.Exp(-decay * progress)) / normalization;
 
            Zoom = _zoomStart + (target - _zoomStart) * easedProgress;
 
            if (_zoomElapsedSeconds >= durationSeconds)
            {
                // This no longer causes a visible jump: easedProgress is already 1.
                SnapZoom(target);
            }
 
            return;
        }
 
        if (_zoomLerpPerSecond <= 0f)
            return;
 
        float t = 1f - MathF.Exp(-_zoomLerpPerSecond * dt);
 
        float newZoom = _zoom + (target - _zoom) * t;
 
        Zoom = newZoom;
 
        if (Math.Abs(newZoom - target) < 1e-4f)
            SnapZoom(target);
    }
    #endregion zoom zoom
}