acdream/tests/AcDream.App.Tests/Rendering/ChargenPreviewControllerTests.cs

using System.Numerics;
using AcDream.App.Rendering;
using AcDream.Content;
using AcDream.Content.CharGen;
using AcDream.Content.Vfx;
using AcDream.Core.CharGen;
using AcDream.Core.Physics.Motion;
using AcDream.Core.World;
using DatReaderWriter;
using DatReaderWriter.Options;
using Xunit;
using Xunit.Abstractions;

namespace AcDream.App.Tests.Rendering;

/// <summary>
/// Campaign CC slice CC6b-MOUNT — installed-DAT gate for
/// <see cref="ChargenPreviewController"/>'s rebuild/render logic, using fake
/// <see cref="IChargenPreviewRenderer"/>/<see cref="IChargenPreviewFrameView"/>
/// implementations (no live GPU device needed — mirrors
/// <c>PaperdollFramePresenterTests</c>'s recording-fake pattern) against a
/// REAL dat-backed <see cref="ChargenOptions"/>/<see cref="ChargenAppearanceCatalog"/>
/// so <c>ChargenAppearanceFactory.TryCompose</c> and
/// <c>ChargenPreviewEntityBuilder.TryBuildAnimated</c> actually run.
/// </summary>
public sealed class ChargenPreviewControllerTests
{
    private readonly ITestOutputHelper _out;
    public ChargenPreviewControllerTests(ITestOutputHelper output) => _out = output;

    private const uint AluvianId = 1u;
    private const uint GearknightId = 6u;

    [Fact]
    public void Rebuild_SameSelectionTwice_IsANoOpSecondTime()
    {
        if (!TryOpen(out DatCollection? dats, out DatCollectionAdapter? adapter))
            return;
        using (dats)
        using (adapter)
        {
            (ChargenOptions options, ChargenAppearanceCatalog catalog) = LoadFixture(adapter!);
            var renderer = new FakeChargenRenderer();
            var view = new FakeChargenView();
            var controller = new ChargenPreviewController(
                renderer, new ChargenPreviewCamera(), view,
                adapter!, new RetailAnimationLoader(adapter!), catalog, catalog, new object());

            ChargenAppearanceSelection selection = DefaultSelection(options, AluvianId, 1);
            Assert.True(controller.Rebuild(options, AluvianId, 1, selection));
            Assert.True(controller.Rebuild(options, AluvianId, 1, selection));

            Assert.Equal(1, renderer.SetPreviewCallCount);
        }
    }

    [Fact]
    public void Rebuild_HeritageChange_ResetsCameraToTheNewHeritagesDefaultEye()
    {
        if (!TryOpen(out DatCollection? dats, out DatCollectionAdapter? adapter))
            return;
        using (dats)
        using (adapter)
        {
            (ChargenOptions options, ChargenAppearanceCatalog catalog) = LoadFixture(adapter!);
            var renderer = new FakeChargenRenderer();
            var view = new FakeChargenView();
            var camera = new ChargenPreviewCamera();
            var controller = new ChargenPreviewController(
                renderer, camera, view,
                adapter!, new RetailAnimationLoader(adapter!), catalog, catalog, new object());

            Assert.True(controller.Rebuild(
                options, AluvianId, 1, DefaultSelection(options, AluvianId, 1)));
            // Poke the SAME camera instance the controller shares (this is
            // exactly the injection seam ChargenPreviewController's own doc
            // comment describes) — simulates the camera having drifted away
            // from the heritage default (e.g. mid zoom-out tween).
            camera.Eye = new Vector3(0f, -99f, 99f);

            if (!options.TryGetHeritage(GearknightId, out ChargenHeritageOptions? gearknight)
                || gearknight!.GendersByKey.Count == 0)
            {
                _out.WriteLine("SKIP: installed dat has no Gearknight gender to switch to.");
                return;
            }
            int gearknightGender = gearknight.GendersByKey.Keys.First();
            Assert.True(controller.Rebuild(
                options, GearknightId, gearknightGender,
                DefaultSelection(options, GearknightId, gearknightGender)));

            Assert.Equal(ChargenPreviewCamera.ResolveDefaultEye(GearknightId), controller.CameraEye);
        }
    }

    /// <summary>
    /// Decomp-cited (<c>gmCGAppearancePage::Update</c>'s two confirmed direct
    /// call sites — <c>InitializePage</c> and the gender-button handlers —
    /// vs the narrower <c>SetSelection</c>/<c>SetColor</c>/<c>SetShade</c>
    /// every spin/color/shade change goes through instead): a rebuild that
    /// changes ONLY the appearance selection (same heritage, same gender)
    /// must NOT snap the camera back to the heritage default.
    /// </summary>
    [Fact]
    public void Rebuild_AppearanceOnlyChange_LeavesTheCameraUntouched()
    {
        if (!TryOpen(out DatCollection? dats, out DatCollectionAdapter? adapter))
            return;
        using (dats)
        using (adapter)
        {
            (ChargenOptions options, ChargenAppearanceCatalog catalog) = LoadFixture(adapter!);
            var renderer = new FakeChargenRenderer();
            var view = new FakeChargenView();
            var camera = new ChargenPreviewCamera();
            var controller = new ChargenPreviewController(
                renderer, camera, view,
                adapter!, new RetailAnimationLoader(adapter!), catalog, catalog, new object());

            ChargenAppearanceSelection first = DefaultSelection(options, AluvianId, 1);
            Assert.True(controller.Rebuild(options, AluvianId, 1, first));
            var pokedEye = new Vector3(0f, -99f, 99f);
            camera.Eye = pokedEye;

            ChargenAppearanceSelection second = first with { SkinShade = 0.9 };
            Assert.True(controller.Rebuild(options, AluvianId, 1, second));

            Assert.Equal(pokedEye, controller.CameraEye);
        }
    }

    [Fact]
    public void Rebuild_PreservesZoomState_AcrossAnAppearanceOnlyChange()
    {
        if (!TryOpen(out DatCollection? dats, out DatCollectionAdapter? adapter))
            return;
        using (dats)
        using (adapter)
        {
            (ChargenOptions options, ChargenAppearanceCatalog catalog) = LoadFixture(adapter!);
            var renderer = new FakeChargenRenderer();
            var view = new FakeChargenView();
            var controller = new ChargenPreviewController(
                renderer, new ChargenPreviewCamera(), view,
                adapter!, new RetailAnimationLoader(adapter!), catalog, catalog, new object());

            ChargenAppearanceSelection first = DefaultSelection(options, AluvianId, 1);
            Assert.True(controller.Rebuild(options, AluvianId, 1, first));
            controller.ZoomIn();
            Assert.True(controller.IsZoomedIn);

            // A DIFFERENT selection, same heritage/gender — retail's
            // gmCGAppearancePage::Update only resets the camera POSITION on
            // heritage/gender change; m_bZoomedIn is untouched by spin/color/
            // shade edits.
            ChargenAppearanceSelection second = first with { SkinShade = 0.9 };
            Assert.True(controller.Rebuild(options, AluvianId, 1, second));

            Assert.True(controller.IsZoomedIn);
        }
    }

    [Fact]
    public void Rebuild_ThenRender_SeedsTheEntityHeadingToTheRetailDefault180Degrees()
    {
        if (!TryOpen(out DatCollection? dats, out DatCollectionAdapter? adapter))
            return;
        using (dats)
        using (adapter)
        {
            (ChargenOptions options, ChargenAppearanceCatalog catalog) = LoadFixture(adapter!);
            var renderer = new FakeChargenRenderer();
            var view = new FakeChargenView();
            var controller = new ChargenPreviewController(
                renderer, new ChargenPreviewCamera(), view,
                adapter!, new RetailAnimationLoader(adapter!), catalog, catalog, new object());

            Assert.True(controller.Rebuild(
                options, AluvianId, 1, DefaultSelection(options, AluvianId, 1)));
            Assert.NotNull(renderer.LastEntity);

            controller.Render();

            Quaternion expected = MoveToMath.SetHeading(
                Quaternion.Identity, ChargenPreviewRotationController.RetailDefaultHeadingDegrees);
            Quaternion actual = renderer.LastEntity!.Rotation;
            Assert.Equal(expected.X, actual.X, 4);
            Assert.Equal(expected.Y, actual.Y, 4);
            Assert.Equal(expected.Z, actual.Z, 4);
            Assert.Equal(expected.W, actual.W, 4);
        }
    }

    [Fact]
    public void Render_WhilePageInvisible_SkipsRenderAndTexturePublication()
    {
        if (!TryOpen(out DatCollection? dats, out DatCollectionAdapter? adapter))
            return;
        using (dats)
        using (adapter)
        {
            (ChargenOptions options, ChargenAppearanceCatalog catalog) = LoadFixture(adapter!);
            var renderer = new FakeChargenRenderer();
            var view = new FakeChargenView { Visible = false };
            var controller = new ChargenPreviewController(
                renderer, new ChargenPreviewCamera(), view,
                adapter!, new RetailAnimationLoader(adapter!), catalog, catalog, new object());
            Assert.True(controller.Rebuild(
                options, AluvianId, 1, DefaultSelection(options, AluvianId, 1)));

            controller.Render();

            Assert.Equal(0, renderer.RenderCallCount);
            Assert.Null(view.LastTextureHandle);
        }
    }

    private static ChargenAppearanceSelection DefaultSelection(
        ChargenOptions options, uint heritageId, int genderKey)
    {
        Assert.True(options.TryGetHeritage(heritageId, out ChargenHeritageOptions? heritage));
        Assert.True(heritage!.GendersByKey.TryGetValue(genderKey, out ChargenGenderOptions? gender));
        return ChargenAppearanceSelection.Default with
        {
            HairStyle = gender!.HairStyles.Count > 0 ? 0u : ChargenAppearanceSelection.Unset,
            SkinShade = 0.5,
        };
    }

    private static (ChargenOptions, ChargenAppearanceCatalog) LoadFixture(IDatReaderWriter dats) =>
        (ChargenTableReader.Load(dats), new ChargenAppearanceCatalog(dats));

    private bool TryOpen(out DatCollection? dats, out DatCollectionAdapter? adapter)
    {
        string? datDir = CornerFloodReplayTests.ResolveDatDir();
        if (datDir is null)
        {
            _out.WriteLine("SKIP: dats unavailable");
            dats = null;
            adapter = null;
            return false;
        }
        dats = new DatCollection(datDir, DatAccessType.Read);
        adapter = new DatCollectionAdapter(dats);
        return true;
    }

    private sealed class FakeChargenRenderer : IChargenPreviewRenderer
    {
        public WorldEntity? LastEntity { get; private set; }
        public int SetPreviewCallCount { get; private set; }
        public int RenderCallCount { get; private set; }

        public void SetPreview(WorldEntity? entity)
        {
            LastEntity = entity;
            SetPreviewCallCount++;
        }

        public uint Render(int width, int height)
        {
            RenderCallCount++;
            return 42u;
        }
    }

    private sealed class FakeChargenView : IChargenPreviewFrameView
    {
        public bool Visible { get; set; } = true;
        public int Width { get; set; } = 128;
        public int Height { get; set; } = 128;
        public uint? LastTextureHandle { get; private set; }

        public bool TryGetVisibleSize(out int width, out int height)
        {
            width = Width;
            height = Height;
            return Visible;
        }

        public void SetTextureHandle(uint textureHandle) => LastTextureHandle = textureHandle;
    }
}