View.cs

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

public sealed class View
{
    private SceneLayer? _zoomAnchorLayer;
    private PointF _zoomAnchorScreenPoint;
    private PointF _zoomAnchorWorldPoint;

    public Guid Id { get; } = Guid.NewGuid();

    public Camera Camera { get; }

    public Viewport Viewport { get; }

    public int ZOrder { get; set; } = 0;

    public float MinZoom { get; set; } = 0.1f;

    public float MaxZoom { get; set; } = 8f;
 
    // Presentation-only state owned by EffectsManager. These values never alter
    // camera, viewport, world, or collision state.
    internal float EffectOpacity { get; set; } = 1f;
    internal float EffectReveal { get; set; } = 1f;
    internal EffectDirection EffectRevealDirection { get; set; } = EffectDirection.FromLeftToRight;
    internal PointF EffectOffsetFactor { get; set; } = PointF.Empty;
    internal PointF EffectOffsetPx { get; set; } = PointF.Empty;
 
    internal bool HasPresentationEffect =>
        EffectOpacity < 0.9999f
        || EffectReveal < 0.9999f
        || Math.Abs(EffectOffsetFactor.X) > 0.0001f
        || Math.Abs(EffectOffsetFactor.Y) > 0.0001f
        || Math.Abs(EffectOffsetPx.X) > 0.0001f
        || Math.Abs(EffectOffsetPx.Y) > 0.0001f;
 
    internal bool BlocksViewsBelow => !HasPresentationEffect;
 
    internal View(Camera cam, Viewport vp)
    {
        Camera = cam;
        Viewport = vp;
        // Let camera clamp against THIS viewport's visible world size.
        Camera.GetVisibleWorldSizePx = () => Viewport.VisibleWorldSizePx;
    }

    public void ZoomAroundScreenPoint(SceneLayer layer, PointF screenPoint, float targetZoom, float durationSeconds)
    {
        ArgumentNullException.ThrowIfNull(layer);
 
        targetZoom = Math.Clamp(targetZoom, MinZoom, MaxZoom);
 
        PointF worldUnderCursor = ScreenPxToWorldPx(layer, screenPoint);
 
        // Anchored zoom owns camera positioning until the zoom completes. Cancel an
        // unrelated explicit pan, but leave follow configuration intact so it can
        // resume on the next update after the anchored zoom finishes.
        Camera.CancelPan();
 
        if (durationSeconds <= 0f)
        {
            ClearZoomAnchor();
            Viewport.SnapZoom(targetZoom);
            SnapCameraToZoomAnchor(layer, screenPoint, worldUnderCursor);
            return;
        }
 
        _zoomAnchorLayer = layer;
        _zoomAnchorScreenPoint = screenPoint;
        _zoomAnchorWorldPoint = worldUnderCursor;
 
        Viewport.ZoomToOverDuration(targetZoom, durationSeconds);
    }

    internal void Update(float dtSeconds)
    {
        if (_zoomAnchorLayer is { } anchorLayer)
        {
            // Update zoom first, then derive the one camera position that keeps
            // the selected world point at the selected screen point.
            Viewport.UpdateZoom(dtSeconds);
            SnapCameraToZoomAnchor(
                anchorLayer,
                _zoomAnchorScreenPoint,
                _zoomAnchorWorldPoint);
 
            if (!Viewport.IsZoomAnimating)
                ClearZoomAnchor();
 
            return;
        }
 
        Camera.Update(dtSeconds);
        Viewport.UpdateZoom(dtSeconds);
    }
 
    private void SnapCameraToZoomAnchor(
        SceneLayer layer,
        PointF screenPoint,
        PointF worldPoint)
    {
        float zoom = Viewport.Zoom > 0f
            ? Viewport.Zoom
            : 1f;
 
        PointF effectOffset = GetEffectOffsetPx(layer);
 
        float offsetX =
            Viewport.TargetRectPx.Left
            + Viewport.ScreenOffsetPx.X
            + effectOffset.X;
 
        float offsetY =
            Viewport.TargetRectPx.Top
            + Viewport.ScreenOffsetPx.Y
            + effectOffset.Y;
 
        float parallax = layer.Parallax;
        if (Math.Abs(parallax) < 1e-6f)
            parallax = 1f;
 
        float localX = screenPoint.X - offsetX;
        float localY = screenPoint.Y - offsetY;
 
        // screen = offset + (world - camera*p) * zoom
        // camera = (world - local/zoom) / p
        float cameraX =
            (worldPoint.X - localX / zoom)
            / parallax;
 
        float cameraY =
            (worldPoint.Y - localY / zoom)
            / parallax;
 
        Camera.SnapTo(new PointF(cameraX, cameraY));
    }
 
    private void ClearZoomAnchor()
    {
        _zoomAnchorLayer = null;
        _zoomAnchorScreenPoint = PointF.Empty;
        _zoomAnchorWorldPoint = PointF.Empty;
    }
 
    #region Coordinate conversion methods

    public PointF ScreenPxToWorldPx(SceneLayer layer, PointF screenPx)
    {
        RenderContext? context = GetCurrentRenderContext();
        float zoom = context?.ViewportZoom
            ?? (Viewport.Zoom <= 0f ? 1f : Viewport.Zoom);
        Rectangle targetRect = context?.ViewportTargetRectPx
            ?? Viewport.TargetRectPx;
        PointF screenOffset = context?.ViewportScreenOffsetPx
            ?? Viewport.ScreenOffsetPx;
        PointF cameraPosition = context?.CameraPositionPx
            ?? Camera.PositionPx;
        PointF effectOffset = GetEffectOffsetPx(layer);
        float offsetX = targetRect.Left + screenOffset.X + effectOffset.X;
        float offsetY = targetRect.Top + screenOffset.Y + effectOffset.Y;
        float parallax = layer.Parallax;
 
        float worldX = cameraPosition.X * parallax
                     + (screenPx.X - offsetX) / zoom;
 
        float worldY = cameraPosition.Y * parallax
                     + (screenPx.Y - offsetY) / zoom;
 
        return new PointF(worldX, worldY);
    }

    public PointF WorldPxToScreenPx(SceneLayer layer, PointF worldPx)
    {
        RenderContext? context = GetCurrentRenderContext();
        float zoom = context?.ViewportZoom
            ?? (Viewport.Zoom <= 0f ? 1f : Viewport.Zoom);
        Rectangle targetRect = context?.ViewportTargetRectPx
            ?? Viewport.TargetRectPx;
        PointF screenOffset = context?.ViewportScreenOffsetPx
            ?? Viewport.ScreenOffsetPx;
        PointF cameraPosition = context?.CameraPositionPx
            ?? Camera.PositionPx;
        PointF effectOffset = GetEffectOffsetPx(layer);
        float offsetX = targetRect.Left + screenOffset.X + effectOffset.X;
        float offsetY = targetRect.Top + screenOffset.Y + effectOffset.Y;
        float parallax = layer.Parallax;
 
        float screenX = offsetX + (worldPx.X - cameraPosition.X * parallax) * zoom;
        float screenY = offsetY + (worldPx.Y - cameraPosition.Y * parallax) * zoom;
 
        return new PointF(screenX, screenY);
    }

    public PointF ScreenPxToGrid(SceneLayer layer, PointF screenPx)
    {
        var worldPx = ScreenPxToWorldPx(layer, screenPx);
        return layer.CoordinateSystem.GetSceneLayerCoordinatesAtPixel(layer, worldPx);
    }

    public RectangleF WorldRectToScreenRect(SceneLayer layer, RectangleF worldRect)
    {
        if (layer is null)
            throw new ArgumentNullException(nameof(layer));
 
        RenderContext? context = GetCurrentRenderContext();
        float zoom = context?.ViewportZoom
            ?? (Viewport.Zoom <= 0f ? 1f : Viewport.Zoom);
        Rectangle targetRect = context?.ViewportTargetRectPx
            ?? Viewport.TargetRectPx;
        PointF screenOffset = context?.ViewportScreenOffsetPx
            ?? Viewport.ScreenOffsetPx;
        PointF cameraPosition = context?.CameraPositionPx
            ?? Camera.PositionPx;
 
        PointF effectOffset = GetEffectOffsetPx(layer);
        float offsetX = targetRect.Left + screenOffset.X + effectOffset.X;
        float offsetY = targetRect.Top + screenOffset.Y + effectOffset.Y;
 
        float parallax = layer.Parallax;
 
        // screen = offset + (world - camera * p) * zoom
        float localLeft = worldRect.Left - cameraPosition.X * parallax;
        float localTop = worldRect.Top - cameraPosition.Y * parallax;
 
        float scaledLeft = localLeft * zoom;
        float scaledTop = localTop * zoom;
        float scaledWidth = worldRect.Width * zoom;
        float scaledHeight = worldRect.Height * zoom;
 
        float screenLeft = offsetX + scaledLeft;
        float screenTop = offsetY + scaledTop;
 
        return new RectangleF(screenLeft, screenTop, scaledWidth, scaledHeight);
    }

    public RectangleF ScreenRectToWorldRect(SceneLayer layer, RectangleF screenRect)
    {
        if (layer is null)
            throw new ArgumentNullException(nameof(layer));
 
        RenderContext? context = GetCurrentRenderContext();
        float zoom = context?.ViewportZoom
            ?? (Viewport.Zoom <= 0f ? 1f : Viewport.Zoom);
        Rectangle targetRect = context?.ViewportTargetRectPx
            ?? Viewport.TargetRectPx;
        PointF screenOffset = context?.ViewportScreenOffsetPx
            ?? Viewport.ScreenOffsetPx;
        PointF cameraPosition = context?.CameraPositionPx
            ?? Camera.PositionPx;
 
        PointF effectOffset = GetEffectOffsetPx(layer);
        float offsetX = targetRect.Left + screenOffset.X + effectOffset.X;
        float offsetY = targetRect.Top + screenOffset.Y + effectOffset.Y;
 
        float parallax = layer.Parallax;
 
        // (screen - offset)
        float localLeft = screenRect.Left - offsetX;
        float localTop = screenRect.Top - offsetY;
 
        // world = camera*parallax + local / zoom
        float worldLeft = cameraPosition.X * parallax + localLeft / zoom;
        float worldTop = cameraPosition.Y * parallax + localTop / zoom;
 
        float worldWidth = screenRect.Width / zoom;
        float worldHeight = screenRect.Height / zoom;
 
        return new RectangleF(worldLeft, worldTop, worldWidth, worldHeight);
    }
 
    internal PointF GetEffectOffsetPx(SceneLayer? layer)
    {
        RenderContext? context = GetCurrentRenderContext();
        PointF factor = context?.ViewEffectOffsetFactor
            ?? EffectOffsetFactor;
        PointF pixels = context?.ViewEffectOffsetPx
            ?? EffectOffsetPx;
        Rectangle targetRect = context?.ViewportTargetRectPx
            ?? Viewport.TargetRectPx;
 
        if (layer is not null)
        {
            factor = new PointF(
                factor.X + layer.EffectOffsetFactor.X,
                factor.Y + layer.EffectOffsetFactor.Y);
            pixels = new PointF(
                pixels.X + layer.EffectOffsetPx.X,
                pixels.Y + layer.EffectOffsetPx.Y);
        }
 
        var wrappedOffset = layer is null ? PointF.Empty : Gondwana.Drawing.WrappedDrawable.ScreenOffset(this, layer);
        return new PointF(
            pixels.X + factor.X * targetRect.Width + wrappedOffset.X,
            pixels.Y + factor.Y * targetRect.Height + wrappedOffset.Y);
    }
 
    internal RectangleF GetPresentationBoundsPx()
    {
        PointF offset = GetEffectOffsetPx(layer: null);
        RectangleF viewport = GetRenderViewportTargetRectPx();
 
        return new RectangleF(
            viewport.Left + offset.X,
            viewport.Top + offset.Y,
            viewport.Width,
            viewport.Height);
    }
 
    internal Rectangle GetRenderViewportTargetRectPx() =>
        GetCurrentRenderContext()?.ViewportTargetRectPx
        ?? Viewport.TargetRectPx;
 
    private RenderContext? GetCurrentRenderContext()
    {
        RenderContext? context = RenderContext.Current;
        return context is not null && ReferenceEquals(context.View, this)
            ? context
            : null;
    }
 
    #endregion Coordinate conversion methods
}