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

using AcDream.App.Rendering;

namespace AcDream.App.Tests.Rendering;

public sealed class GameWindowRenderLeafCompositionTests
{
    [Fact]
    public void ProductionRender_PreservesPrivatePresentationAndCaptureOrder()
    {
        string presentation = Source("PrivatePresentationRenderer.cs");
        string orchestrator = Source("RenderFrameOrchestrator.cs");

        AssertAppearsInOrder(
            presentation,
            "_portal.Draw(",
            "_paperdoll?.Render();",
            "_gameplayUi?.Render(",
            "_devTools?.Render(",
            "_screenshots?.CapturePending(");
        AssertAppearsInOrder(
            orchestrator,
            "_world.Render(input);",
            "_presentation.Render(input, world);",
            "_diagnostics.Publish(input, outcome);");
    }

    [Fact]
    public void ProductionRender_Prepares_resources_then_devtools_weather_and_world()
    {
        string source = Source("RenderFramePreparationController.cs");

        AssertAppearsInOrder(
            source,
            "_resources.Prepare(input);",
            "_devTools?.BeginFrame((float)input.DeltaSeconds);",
            "_weather.Tick(input.DeltaSeconds);");
    }

    [Fact]
    public void Composition_transfers_portal_tunnel_before_constructing_frame_borrowers()
    {
        string phase = File.ReadAllText(Path.Combine(
            FindRepoRoot(),
            "src",
            "AcDream.App",
            "Composition",
            "SessionPlayerComposition.cs"));
        string source = GameWindowSource();
        string framePhase = FrameRootSource();

        AssertAppearsInOrder(
            phase,
            "d.PortalTunnelFallback.Transfer(",
            "new LocalPlayerTeleportController(",
            "new LocalPlayerTeleportPresentation(portalTunnel)",
            "d.TeleportSink.BindOwned(localTeleport)",
            "_publication.PublishSessionPlayer(result);");
        AssertAppearsInOrder(
            source,
            "new SessionPlayerCompositionPhase(",
            "new FrameRootCompositionPhase(");
        AssertAppearsInOrder(
            framePhase,
            "new LocalPlayerTeleportRenderStateSource(",
            "new RenderFrameResourceController(",
            "new PrivatePresentationRenderer(",
            "new RenderFrameOrchestrator(");
    }

    [Fact]
    public void ProductionComposition_RemovesLegacyLeafOwnership()
    {
        string source = GameWindowSource();

        string[] removed =
        [
            "_imguiBootstrap",
            "_panelHost",
            "_paperdollDollDirty",
            "RefreshPaperdollDoll",
            "ApplyPaperdollPose",
            "ResolvePaperdollPoseDid",
            "EnumerateDebugPanel",
            "ResetPanelLayout",
            "SetPanelLayout",
            "_lastRenderSignature",
            "private void EmitRenderSignatureIfChanged(",
            "private void EmitRetailPViewDiagnostics(",
            "EmitGlStateTripwireIfChanged();",
            "EmitClipRouteScissorProbe(scissor",
            "_lastVisibleLandblocks",
            "_perfAccum",
            "_entityUploadTiming",
            "_weatherAccum",
            "TryGetLoginWorldCell",
            "ApplyFramePacingPreference",
            "RefreshActiveMonitorFramePacing",
            "private void OnFrameRendered(",
            "private AcDream.App.Rendering.WorldRenderDiagnostics? _worldRenderDiagnostics",
            "private AcDream.App.Rendering.WorldRenderFrameBuilder?",
            "private AcDream.App.Rendering.SkyPesFrameController?",
            "private AcDream.App.Rendering.RetailPViewRenderer?",
            "private AcDream.App.Rendering.RetailPViewPassExecutor?",
            "private AcDream.App.Rendering.RetailPViewCellSource?",
            "private AcDream.App.Rendering.TerrainDrawDiagnosticsController?",
        ];
        foreach (string identifier in removed)
            Assert.DoesNotContain(identifier, source, StringComparison.Ordinal);

        Assert.Contains("new PaperdollFramePresenter(", LivePresentationSource());
        string settingsComposition = File.ReadAllText(Path.Combine(
            FindRepoRoot(),
            "src",
            "AcDream.App",
            "Composition",
            "SettingsDevToolsComposition.cs"));
        Assert.Contains("new DevToolsFramePresenter(", settingsComposition);
        string framePhase = FrameRootSource();
        Assert.Contains("new RenderFrameResourceController(", framePhase);
        Assert.Contains("new RenderWeatherFrameController(", framePhase);
        Assert.Contains("new PrivatePresentationRenderer(", framePhase);
        Assert.Contains("new RenderFrameOrchestrator(", framePhase);
        Assert.Contains("new DisplayFramePacingController(", source);
        string pointerSource = File.ReadAllText(Path.Combine(
            FindRepoRoot(),
            "src",
            "AcDream.App",
            "Input",
            "CameraPointerInputController.cs"));
        Assert.Contains("_capture.WantCaptureMouse", pointerSource);
    }

    [Fact]
    public void Shutdown_PreservesBorrowedDevtoolsLifetimeAndDrainsGpuBeforeFrontends()
    {
        string source = GameWindowSource();

        AssertAppearsInOrder(
            source,
            "new ResourceShutdownStage(\"submitted GPU work\"",
            "new ResourceShutdownStage(\"render frontends\"",
            "new(\"developer tools\"",
            "owner.DisposeFrontend()",
            "new(\"portal tunnel\"",
            "new(\"paperdoll viewport\"",
            "new ResourceShutdownStage(\"OpenGL context\"");
        AssertAppearsInOrder(
            source,
            "new ResourceShutdownStage(\"frame borrowers\"",
            "publication.Dispose();",
            "bindings.Dispose();",
            "new ResourceShutdownStage(\"session dependents\"");
        AssertAppearsInOrder(
            source,
            "new(\"frame pacing\", _displayFramePacing.Dispose)",
            "new(\"frame profiler\", _frameProfiler.Dispose)");
        AssertAppearsInOrder(
            source,
            "publication.Dispose();",
            "owner.DisposeFrontend()",
            "new ResourceShutdownStage(\"input\"",
            "_input?.Dispose();",
            "new ResourceShutdownStage(\"OpenGL context\"");
    }

    [Fact]
    public void ProductionOutcome_UsesObservedWorldAndScreenshotFacts()
    {
        string presentation = Source("PrivatePresentationRenderer.cs");
        string orchestrator = Source("RenderFrameOrchestrator.cs");

        AssertAppearsInOrder(
            presentation,
            "_foundation.Foundation.PortalViewportVisible;",
            "_portal.Draw(",
            "bool screenshotCaptured = _screenshots?.CapturePending(",
            "portalViewportVisible,",
            "screenshotCaptured);");
        AssertAppearsInOrder(
            orchestrator,
            "WorldRenderFrameOutcome world = _world.Render(input);",
            "_presentation.Render(input, world);",
            "new RenderFrameOutcome(world, presentation);",
            "_diagnostics.Publish(input, outcome);");
    }

    [Fact]
    public void GameWindow_OnRenderIsOneImmutableOrchestratorHandoff()
    {
        string source = GameWindowSource();
        int start = source.IndexOf(
            "private void OnRender(double deltaSeconds)",
            StringComparison.Ordinal);
        int end = source.IndexOf(
            "private void OnFramebufferResize(",
            start,
            StringComparison.Ordinal);
        Assert.True(start >= 0 && end > start);
        string body = source[start..end];

        Assert.Equal(1, CountOccurrences(body, "_frameGraphs.Render("));
        Assert.DoesNotContain("_gpuFrameFlights", body);
        Assert.DoesNotContain("_worldScene", body);
        Assert.DoesNotContain("_devToolsFramePresenter", body);
        Assert.DoesNotContain("_retailUiRuntime", body);
        Assert.DoesNotContain("_frameScreenshots", body);
    }

    [Fact]
    public void PaperdollComposition_SkipsEitherMissingOptionalUiSurface()
    {
        string source = LivePresentationSource();

        AssertAppearsInOrder(
            source,
            "PaperdollViewportWidget is { } viewport",
            "InventoryFrame is { } inventoryFrame",
            "new PaperdollFramePresenter(");
        Assert.DoesNotContain("Paperdoll inventory frame is required.", source);
    }

    [Fact]
    public void TerrainAndFrameDiagnostics_AreComposedAsOneFocusedOwner()
    {
        string source = FrameRootSource();

        Assert.Contains(
            "new TerrainDrawDiagnosticsController(",
            source);
        Assert.Contains("new WorldScenePassExecutor(", source);
        Assert.DoesNotContain("_terrainDrawDiagnostics!.Begin();", source);
        Assert.DoesNotContain("_terrainDrawDiagnostics.Complete();", source);
    }

    private static string GameWindowSource() => File.ReadAllText(Path.Combine(
        FindRepoRoot(),
        "src",
        "AcDream.App",
        "Rendering",
        "GameWindow.cs"));

    private static string LivePresentationSource() => File.ReadAllText(Path.Combine(
        FindRepoRoot(),
        "src",
        "AcDream.App",
        "Composition",
        "LivePresentationComposition.cs"));

    private static string FrameRootSource() => File.ReadAllText(Path.Combine(
        FindRepoRoot(),
        "src",
        "AcDream.App",
        "Composition",
        "FrameRootComposition.cs"));

    private static string Source(string fileName) => File.ReadAllText(Path.Combine(
        FindRepoRoot(),
        "src",
        "AcDream.App",
        "Rendering",
        fileName));

    private static int CountOccurrences(string source, string value)
    {
        int count = 0;
        int cursor = 0;
        while ((cursor = source.IndexOf(value, cursor, StringComparison.Ordinal)) >= 0)
        {
            count++;
            cursor += value.Length;
        }
        return count;
    }

    private static void AssertAppearsInOrder(string source, params string[] needles)
    {
        int cursor = -1;
        foreach (string needle in needles)
        {
            int next = source.IndexOf(needle, cursor + 1, StringComparison.Ordinal);
            Assert.True(next >= 0, $"Missing expected source fragment: {needle}");
            Assert.True(next > cursor, $"Out-of-order source fragment: {needle}");
            cursor = next;
        }
    }

    private static string FindRepoRoot()
    {
        DirectoryInfo? directory = new(AppContext.BaseDirectory);
        while (directory is not null)
        {
            if (File.Exists(Path.Combine(directory.FullName, "AcDream.slnx")))
                return directory.FullName;
            directory = directory.Parent;
        }

        throw new DirectoryNotFoundException("Could not find AcDream.slnx.");
    }
}