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

using System;
using System.Collections.Generic;
using System.Numerics;
using AcDream.App.Rendering;
using DatReaderWriter;
using DatReaderWriter.Options;
using Xunit;
using Xunit.Abstractions;

namespace AcDream.App.Tests.Rendering;

/// <summary>
/// #130 — background-color strip along the TOP outer edge of a doorway when
/// looking out from inside. Mechanism model (2026-06-12 evidence sweep): for
/// an interior root the SEAL stamps the FULL raw dat portal polygon at true
/// depth (PortalDepthMaskRenderer, root-cell slice = full screen), while
/// terrain/sky COLOR used to be gated per fragment by the OutsideView region —
/// the same dat polygon run through ProjectToClip → ClipToRegion (1-px
/// MergeSubPixelVertices) → ClipPlaneSet.From (0.5° collinear merge) → planes,
/// with a Floor/Ceil pixel scissor (the sky's own doorway scissor bracket)
/// on the slice AABB on top. Every one of those passes could only SHRINK the gate, so any
/// shave showed as a strip of clear color between the gate's top edge and the
/// aperture's rasterized top edge.
///
/// RETIRED MECHANISM (S3 chunk 4 fix round 2, L7): the scissor half of this
/// story no longer applies. Retail draws the sky and the landscape unclipped
/// (<c>LScape::draw</c> never installs a view before either — S3 chunk 3/4's
/// own findings), and acdream now matches that: the sky's own doorway
/// scissor bracket, <c>IWorldPassSurface.BeginScissor/EndScissor</c>, and
/// every per-slice terrain/sky/weather clip they used to bracket are deleted
/// outright. An
/// interior root's aperture exactness comes instead from the depth clear, the
/// exit seals, and the interior repaint (<c>WalkFrameDriver</c>'s interior
/// turn draws the real cell geometry back over whatever the unclipped
/// landscape painted through the doorway) — see the S3 chunk 4 plan section
/// for the retail citations.
///
/// What remains below still pins something production reads: the outside-view
/// polygon pipeline (<c>ProjectToClip</c> → <c>ClipToRegion</c> →
/// <c>ClipPlaneSet.From</c>) that the KEPT punch-fan clip still consumes
/// (<c>RetailPViewPassExecutor.DrawWalkPunchFan</c> reads
/// <c>clipAssembly.OutsideViewSlices[activeViewIndex].Planes</c> — see
/// <c>ClipFrameLayoutTests</c>'s punch-fan equivalence pin for the synthetic-
/// view version of this same proof). This harness measures the PLANE gap
/// headlessly at the real Holtburg corner building exit door (A9B4 0x0170,
/// the HouseExitWalkReplay door): project the aperture, run the production
/// flood + assembler, then walk sample points just inside the aperture's top
/// edge downward until the plane gate admits them.
///
/// VERDICT (2026-06-12, 147 eye/gaze combos, plane half only — the original
/// sweep also measured a scissor gap, since retired): the CPU polygon
/// pipeline is sub-pixel exact (worst 0.54 px) — the W=0 clip port 987313a
/// and both merge passes are EXONERATED. PIN 2 below still asserts that
/// bound.
/// </summary>
[Trait("Lane", "InstalledDat")]
public class Issue130DoorwayStripTests
{
    private readonly ITestOutputHelper _out;
    public Issue130DoorwayStripTests(ITestOutputHelper output) => _out = output;

    private const uint ExitCellId = CornerFloodReplayTests.Landblock | 0x0170u;

    // Production projection convention (CornerFloodReplayTests.ViewProjFor):
    // FovY 1.2 rad, 1280x720 viewport, near 1, far 5000. The flood clip is
    // near-independent so near/far exactness is not load-bearing.
    private static Matrix4x4 ViewProjFor(Vector3 eye, Vector3 lookAt)
    {
        var view = Matrix4x4.CreateLookAt(eye, lookAt, Vector3.UnitZ);
        var proj = Matrix4x4.CreatePerspectiveFieldOfView(1.2f, 1280f / 720f, 1f, 5000f);
        return view * proj;
    }

    [Fact]
    public void ExitDoorTopEdge_GateCoversTheDrawnApertureWithinPixelTolerance()
    {
        var datDir = CornerFloodReplayTests.ResolveDatDir();
        if (datDir is null) { _out.WriteLine("SKIP: dats unavailable"); Assert.Fail("Lane=InstalledDat requires an installed retail DAT directory; see docs/release-gate.md."); }

        using var dats = new DatCollection(datDir, DatAccessType.Read);
        var cells = CornerFloodReplayTests.LoadBuilding(dats);
        var root = cells[ExitCellId];
        LoadedCell? Lookup(uint id) => cells.TryGetValue(id, out var c) ? c : null;

        // Find the exit portal (OtherCellId == 0xFFFF) and its world polygon.
        int exitIdx = -1;
        for (int i = 0; i < root.Portals.Count; i++)
        {
            if (root.Portals[i].OtherCellId == 0xFFFF && i < root.PortalPolygons.Count
                && root.PortalPolygons[i].Length >= 3)
            { exitIdx = i; break; }
        }
        Assert.True(exitIdx >= 0, "0x0170 has no exit portal polygon");

        var localPoly = root.PortalPolygons[exitIdx];
        // Campaign FW3.3: ShellDrawLiftZ is retired — shells, seal fans, and
        // the gate all live in the ONE dat space, so the drawn aperture IS
        // the physics polygon. This test survives as the coverage proof
        // (gate covers the drawn hole within tolerance across the sweep);
        // the historical lifted-vs-unlifted strip test's premise (two
        // spaces) no longer exists and that test is deleted.
        var worldPoly = new Vector3[localPoly.Length];
        for (int i = 0; i < localPoly.Length; i++)
            worldPoly[i] = Vector3.Transform(localPoly[i], root.WorldTransform);

        Vector3 centroid = Vector3.Zero;
        foreach (var w in worldPoly) centroid += w;
        centroid /= worldPoly.Length;

        // Inward direction: the portal plane normal signed toward the cell
        // interior (ClipPlanes carries InsideSide from the load).
        var plane = root.ClipPlanes[exitIdx];
        var worldNormal = Vector3.TransformNormal(plane.Normal, root.WorldTransform);
        var cellCenterWorld = Vector3.Transform(
            (root.LocalBoundsMin + root.LocalBoundsMax) * 0.5f, root.WorldTransform);
        if (Vector3.Dot(worldNormal, cellCenterWorld - centroid) < 0)
            worldNormal = -worldNormal;
        worldNormal = Vector3.Normalize(worldNormal);

        _out.WriteLine(FormattableString.Invariant(
            $"exit portal idx={exitIdx} verts={localPoly.Length} centroid=({centroid.X:F2},{centroid.Y:F2},{centroid.Z:F2}) inward=({worldNormal.X:F2},{worldNormal.Y:F2},{worldNormal.Z:F2})"));
        for (int i = 0; i < worldPoly.Length; i++)
            _out.WriteLine(FormattableString.Invariant(
                $"  poly[{i}] world=({worldPoly[i].X:F3},{worldPoly[i].Y:F3},{worldPoly[i].Z:F3})"));

        float worstPlaneGapPx = 0f;
        string worstDesc = "(none)";

        // Eye sweep: back off the doorway along the inward normal at several
        // distances/heights/lateral offsets; gaze at the centroid plus raised /
        // lowered targets (NDC alignment of the top edge varies with gaze).
        var lateral = Vector3.Normalize(Vector3.Cross(worldNormal, Vector3.UnitZ));
        float[] dists = { 0.6f, 1.0f, 1.6f, 2.4f, 3.5f };
        float[] heights = { 0.9f, 1.4f, 1.7f };
        float[] laterals = { -0.8f, 0f, 0.8f };
        float[] gazeRaise = { -0.4f, 0f, 0.4f, 0.9f };

        int evaluated = 0;
        foreach (float d in dists)
        foreach (float h in heights)
        foreach (float lat in laterals)
        foreach (float gz in gazeRaise)
        {
            var eye = centroid + worldNormal * d + lateral * lat;
            eye.Z = centroid.Z - 1.0f + h; // door centroid sits mid-opening; bias to floor-ish
            var look = centroid + new Vector3(0, 0, gz);
            var viewProj = ViewProjFor(eye, look);

            // Aperture truth: the seal's footprint = the raw polygon's projection.
            var clip = new Vector4[worldPoly.Length];
            float minW = float.MaxValue;
            for (int i = 0; i < worldPoly.Length; i++)
            {
                clip[i] = Vector4.Transform(new Vector4(worldPoly[i], 1f), viewProj);
                minW = MathF.Min(minW, clip[i].W);
            }
            if (minW <= 0.05f) continue; // eye in/behind the door plane — out of #130's scenario
            var aperture = new Vector2[clip.Length];
            for (int i = 0; i < clip.Length; i++)
                aperture[i] = new Vector2(clip[i].X / clip[i].W, clip[i].Y / clip[i].W);

            var pv = PortalVisibilityBuilder.Build(root, eye, Lookup, viewProj,
                buildingMembership: null);
            var asm = ClipFrameAssembler.Assemble(ClipFrame.NoClip(), pv);
            if (asm.OutsideViewSlices.Length == 0)
            {
                _out.WriteLine(FormattableString.Invariant(
                    $"d={d} h={h} lat={lat} gz={gz}: NO outside slice (outPolys={pv.OutsideView.Polygons.Count})"));
                continue;
            }
            evaluated++;

            (float planeGapPx, float atX) =
                MeasureTopEdgeGap(aperture, asm.OutsideViewSlices, 1080);

            if (planeGapPx > worstPlaneGapPx)
            {
                worstDesc = FormattableString.Invariant(
                    $"d={d} h={h} lat={lat} gz={gz} minW={minW:F2} atX={atX:F3} slices={asm.OutsideViewSlices.Length} outVerts={DescribePolys(pv.OutsideView)} apVerts={aperture.Length}");
                worstPlaneGapPx = planeGapPx;
            }

            if (planeGapPx > 0.55f)
            {
                _out.WriteLine(FormattableString.Invariant(
                    $"GAP d={d} h={h} lat={lat} gz={gz}: planeGap={planeGapPx:F2}px atX={atX:F3} outVerts={DescribePolys(pv.OutsideView)}"));
                float apTop = TopBoundaryY(aperture, atX);
                foreach (var slice in asm.OutsideViewSlices)
                    _out.WriteLine(FormattableString.Invariant(
                        $"  slice slot={slice.Slot} planes={slice.Planes.Length} aabb=({slice.NdcAabb.X:F4},{slice.NdcAabb.Y:F4},{slice.NdcAabb.Z:F4},{slice.NdcAabb.W:F4}) apTopAtX={apTop:F4}"));
                foreach (var poly in pv.OutsideView.Polygons)
                {
                    var sb = new System.Text.StringBuilder("  outPoly:");
                    foreach (var v in poly.Vertices)
                        sb.Append(FormattableString.Invariant($" ({v.X:F4},{v.Y:F4})"));
                    _out.WriteLine(sb.ToString());
                }
            }
        }

        _out.WriteLine(FormattableString.Invariant(
            $"evaluated={evaluated} worstPlaneGapPx={worstPlaneGapPx:F2} @ {worstDesc}"));

        Assert.True(evaluated > 100, $"sweep degenerated: only {evaluated} eye/gaze combos evaluated");
        // PIN (canary): the CPU polygon pipeline (ProjectToClip → ClipToRegion
        // merges → ClipPlaneSet planes) stays sub-pixel exact against the raw
        // aperture projection. Observed 0.54 px worst (2026-06-12); the
        // production vertex-merge floor is ~1 px — beyond 1.2 px means a new
        // under-inclusion shaver entered the pipeline.
        Assert.True(worstPlaneGapPx <= 1.2f, FormattableString.Invariant(
            $"plane gate under-covers the aperture top edge by {worstPlaneGapPx:F2}px @ {worstDesc}"));
    }

    private static string DescribePolys(CellView view)
    {
        var parts = new List<string>();
        foreach (var p in view.Polygons) parts.Add(p.Vertices.Length.ToString());
        return $"[{string.Join(",", parts)}]";
    }

    /// <summary>
    /// For sample x positions across the aperture's projected top edge, find the
    /// aperture boundary's top y, then walk downward until the plane gate
    /// admits the point. Returns the worst gap in 1080p pixels, and the x of
    /// the worst gap. S3 chunk 4 fix round 2 (L7): the scissor-gap half this
    /// used to measure alongside the plane gap is deleted — the scissor
    /// mechanism it modeled no longer exists in production.
    /// </summary>
    private static (float planeGapPx, float atX) MeasureTopEdgeGap(
        Vector2[] aperture, ClipViewSlice[] slices, int fbH,
        ITestOutputHelper? debug = null)
    {
        const float Inset = 1e-4f;   // dodge exact-boundary ambiguity
        const float StepY = 0.0002f; // ~0.1 px at 1080p
        const float CapY = 0.02f;    // stop searching beyond ~10 px

        float minX = float.MaxValue, maxX = float.MinValue;
        foreach (var v in aperture) { minX = MathF.Min(minX, v.X); maxX = MathF.Max(maxX, v.X); }
        float span = maxX - minX;
        if (span <= 0.01f) return (0, 0);

        float worstPlane = 0, atX = 0;
        const int Samples = 160;
        for (int s = 0; s <= Samples; s++)
        {
            float x = minX + span * (0.01f + 0.98f * s / Samples);
            if (MathF.Abs(x) > 0.98f) continue; // off screen — no pixel exists there
            float topY = TopBoundaryY(aperture, x);
            if (float.IsNaN(topY) || MathF.Abs(topY) > 0.98f) continue; // off screen / no boundary

            var p = new Vector2(x, topY - Inset);

            float planeGap = GapBelow(p, q => AnySliceAdmitsPlanes(slices, q), StepY, CapY);

            if (debug is not null && planeGap > 0.005f)
                debug.WriteLine(FormattableString.Invariant(
                    $"    sample x={x:F4} apTop={topY:F4} planeGap={planeGap * fbH / 2f:F2}px"));

            if (planeGap > worstPlane) { worstPlane = planeGap; atX = x; }
        }
        // NDC y → pixels at the given framebuffer height.
        return (worstPlane * fbH / 2f, atX);
    }

    private static float GapBelow(Vector2 start, Func<Vector2, bool> admitted, float step, float cap)
    {
        if (admitted(start)) return 0f;
        for (float dy = step; dy <= cap; dy += step)
        {
            if (admitted(new Vector2(start.X, start.Y - dy)))
                return dy;
        }
        return cap;
    }

    // Production semantics: each OutsideView polygon is one slice; the union of
    // slices is drawn. A slice with planes gates per fragment via
    // gl_ClipDistance (dot((nx,ny,0,d),(x,y,z,1)) >= 0 for an NDC point);
    // a planeless slice (>8-edge zero-plane fallback, ClipFrameAssembler.cs) admits its whole NDC AABB.
    private static bool AnySliceAdmitsPlanes(ClipViewSlice[] slices, Vector2 p)
    {
        foreach (var slice in slices)
        {
            if (slice.Planes.Length == 0)
            {
                if (p.X >= slice.NdcAabb.X && p.Y >= slice.NdcAabb.Y
                    && p.X <= slice.NdcAabb.Z && p.Y <= slice.NdcAabb.W)
                    return true;
                continue;
            }
            bool inside = true;
            foreach (var pl in slice.Planes)
            {
                if (pl.X * p.X + pl.Y * p.Y + pl.W < 0f) { inside = false; break; }
            }
            if (inside) return true;
        }
        return false;
    }

    /// <summary>Highest boundary y of the polygon at vertical line x (NaN when
    /// the line misses the polygon).</summary>
    private static float TopBoundaryY(Vector2[] poly, float x)
    {
        float best = float.NaN;
        for (int i = 0; i < poly.Length; i++)
        {
            var a = poly[i];
            var b = poly[(i + 1) % poly.Length];
            if (MathF.Abs(a.X - b.X) < 1e-9f)
            {
                if (MathF.Abs(a.X - x) < 1e-6f)
                {
                    float hi = MathF.Max(a.Y, b.Y);
                    if (float.IsNaN(best) || hi > best) best = hi;
                }
                continue;
            }
            float t = (x - a.X) / (b.X - a.X);
            if (t < 0f || t > 1f) continue;
            float y = a.Y + t * (b.Y - a.Y);
            if (float.IsNaN(best) || y > best) best = y;
        }
        return best;
    }
}