acdream/src/AcDream.App/Rendering/ChargenPreviewZoomController.cs

using System.Numerics;

namespace AcDream.App.Rendering;

/// <summary>
/// Presentation-free port of <c>gmCGAppearancePage::ZoomIn</c>/<c>ZoomOut</c>
/// (<c>0x0047CF00</c>/<c>0x0047D050</c>) and <c>DoZoomAnimation</c>
/// (<c>0x0047C960</c>): a linear 0.6s tween of the preview camera's eye
/// between <see cref="ChargenPreviewCamera.ResolveDefaultEye"/> (zoomed IN)
/// and <see cref="ChargenPreviewCamera.ResolveZoomedOutEye"/> (zoomed OUT),
/// driving the SAME <see cref="ChargenPreviewAnimator"/> zoom-state swap the
/// button presses trigger in retail — immediately, not once the tween
/// finishes (see <see cref="ChargenPreviewAnimator"/>'s own doc comment).
///
/// <para>
/// <b>One owner of the zoom state (fix round F2):</b> retail's
/// <c>m_bZoomedIn</c> is a SINGLE field on <c>gmCGAppearancePage</c> that
/// gates both the camera target AND the animation swap — there is no way
/// for retail's own camera and animation to disagree about which zoom state
/// they're in. The first cut of this port kept two independent bools (one
/// here, one on <see cref="ChargenPreviewAnimator"/>) synced only by
/// <see cref="ZoomIn"/>/<see cref="ZoomOut"/> calling a NULLABLE animator
/// parameter — a null pass, or any direct
/// <see cref="ChargenPreviewAnimator.SetZoomedIn"/> call bypassing this
/// controller, would desync the camera's target from the animation's pose.
/// This class now takes its <see cref="ChargenPreviewAnimator"/> as a
/// REQUIRED constructor dependency and <see cref="IsZoomedIn"/> reads
/// straight through to <see cref="ChargenPreviewAnimator.IsZoomedIn"/> — the
/// animator is the sole state owner, matching retail's own single-field
/// design, and there is no longer a second bool that could disagree with it.
/// </para>
///
/// <para>
/// Retail drives <see cref="Tick"/> once per frame from a global-message-3
/// tick while <c>m_bShouldZoomAnimate</c> is set
/// (<c>gmCGAppearancePage::ListenToGlobalMessage @ 0x0047CED0</c>); the
/// CC6b page-mount half will bind the Zoom In/Out buttons to
/// <see cref="ZoomIn"/>/<see cref="ZoomOut"/> and the render loop to
/// <see cref="Tick"/>. Direction is always <c>(0,0,0)</c> for this camera
/// (see <see cref="ChargenPreviewCamera"/>'s own remarks), so only the eye
/// position tweens — retail's own <c>m_vectCurDirection</c> lerp is a no-op
/// here and is not reproduced.
/// </para>
/// </summary>
internal sealed class ChargenPreviewZoomController
{
    /// <summary>
    /// <c>ZoomIn</c>/<c>ZoomOut</c>'s explicit invalidation write
    /// (<c>this->m_dAnimDuration = -0.1</c>, pseudo-C ~0x0047cff1/0x0047cffb
    /// and ~0x0047d12c/0x0047d136 — the exact IEEE-754 bit pattern for
    /// <c>-0.1</c>) so the very next <see cref="Tick"/> resets the duration
    /// to <see cref="ChargenPreviewCamera.ZoomTweenDurationSeconds"/> and the
    /// start time to "now", matching <c>DoZoomAnimation</c>'s own
    /// reset-if-invalid guard exactly.
    /// </summary>
    private const double InvalidDurationSentinel = -0.1;

    private readonly uint _heritageId;
    private readonly ChargenPreviewAnimator _animator;
    private Vector3 _startEye;
    private Vector3 _targetEye;
    private double _animStartTime;
    private double _animDuration;
    private bool _shouldAnimate;

    public ChargenPreviewZoomController(uint heritageId, ChargenPreviewCamera camera, ChargenPreviewAnimator animator)
    {
        ArgumentNullException.ThrowIfNull(camera);
        ArgumentNullException.ThrowIfNull(animator);
        _heritageId = heritageId;
        Camera = camera;
        _animator = animator;
    }

    public ChargenPreviewCamera Camera { get; }

    /// <summary>
    /// Mirrors retail's <c>m_bZoomedIn</c> — a straight read-through to
    /// <see cref="ChargenPreviewAnimator.IsZoomedIn"/> (see this class's own
    /// "one owner" doc above), which itself defaults false per
    /// <c>gmCGAppearancePage::InitializePage @ 0x0047FDD0</c>'s explicit
    /// <c>this-&gt;m_bZoomedIn = 0;</c> at <c>0x004802C3</c> — written right
    /// after that same function points the camera at the zoomed-IN
    /// per-heritage eye (<c>0x00480286-0x0048029E</c>). One retail quirk
    /// this produces: the character starts framed close-up while
    /// NOT-zoomed-in, so the first Zoom In click (once mounted) tweens
    /// close-eye→close-eye — visually null — while still freezing the
    /// animation; this port reproduces it faithfully.
    /// </summary>
    public bool IsZoomedIn => _animator.IsZoomedIn;

    /// <summary>
    /// <c>gmCGAppearancePage::ZoomIn @ 0x0047CF00</c>: no-op if already
    /// zoomed in (retail's own early-return guard). Otherwise starts a tween
    /// from the camera's CURRENT eye to the default (zoomed-IN) per-heritage
    /// profile and swaps the animator to the frozen rest pose IMMEDIATELY
    /// (<c>gmCG3DView::StopAnimation</c>'s call site, pseudo-C ~0x0047d024,
    /// precedes the tween's own completion by definition — it runs once,
    /// synchronously, inside <c>ZoomIn</c> itself).
    /// </summary>
    public void ZoomIn()
    {
        if (IsZoomedIn)
            return;
        StartTween(ChargenPreviewCamera.ResolveDefaultEye(_heritageId));
        _animator.SetZoomedIn(true);
    }

    /// <summary>
    /// <c>gmCGAppearancePage::ZoomOut @ 0x0047D050</c>: no-op if not
    /// currently zoomed in. Otherwise starts a tween toward the zoomed-OUT
    /// per-heritage profile and swaps the animator back to the playing idle
    /// loop immediately, mirroring <see cref="ZoomIn"/>.
    /// </summary>
    public void ZoomOut()
    {
        if (!IsZoomedIn)
            return;
        StartTween(ChargenPreviewCamera.ResolveZoomedOutEye(_heritageId));
        _animator.SetZoomedIn(false);
    }

    private void StartTween(Vector3 targetEye)
    {
        _startEye = Camera.Eye;
        _targetEye = targetEye;
        _shouldAnimate = true;
        _animDuration = InvalidDurationSentinel;
    }

    /// <summary>
    /// <c>gmCGAppearancePage::DoZoomAnimation @ 0x0047C960</c>: a LINEAR
    /// (not eased) lerp of the eye position from <c>m_vectStartPosition</c>
    /// to <c>m_vectTargPosition</c> over
    /// <see cref="ChargenPreviewCamera.ZoomTweenDurationSeconds"/>, clamping
    /// <c>t</c> to exactly 1.0 (and clearing <c>m_bShouldZoomAnimate</c>) the
    /// tick that reaches or passes the duration — the decomp shows a
    /// straight <c>(targ - start) * t + start</c> per axis with no easing
    /// curve applied anywhere in this function.
    /// </summary>
    public void Tick(double now)
    {
        if (!_shouldAnimate)
            return;

        if (_animDuration <= 0d)
        {
            _animDuration = ChargenPreviewCamera.ZoomTweenDurationSeconds;
            _animStartTime = now;
        }

        double elapsed = now - _animStartTime;
        if (elapsed >= _animDuration)
        {
            _shouldAnimate = false;
            elapsed = _animDuration;
        }

        float t = (float)(elapsed / _animDuration);
        Camera.Eye = Vector3.Lerp(_startEye, _targetEye, t);
    }
}