5135066733
The user's re-gate refuted the scissor fix as THE strip (6c4b6d6was a real but sub-pixel under-coverage): the strip survived, screenshot at a doorway, full width of the opening, top edge only, "very subtle". Root cause (pinned by Issue130DoorwayStripTests.UnliftedGate_*): the +0.02 m shell render lift. Cell shells DRAW 2 cm above the dat origin (z-fight vs coplanar terrain);f35cb8b(the #119-residual fix, 2026-06-11) deliberately reverted the VISIBILITY graph to the physics (unlifted) transform - but the OutsideView color gate (terrain/sky/ scissor through the doorway) and the seal/punch depth fans are DRAW-space consumers and kept projecting the unlifted polygons. The drawn lintel therefore sits one lift-projection above the gate's top edge - measured 6.7 px at a 2.4 m doorway - and that band never receives terrain/sky color while the seal also stamps 2 cm low. A regression fromf35cb8b, NOT from the W=0 clip port (987313astays exonerated). Vertical aperture edges are immune (the lift slides them along themselves) - top edge only, exactly as reported; explains the "also NOW" timing precisely. Fix - draw space draws lifted, visibility stays physics (thef35cb8binvariant, now symmetric): - PortalVisibilityBuilder.Build gains drawLiftZ: the exit-portal branch projects the OutsideView region with the lifted transform; flood admission, side tests, and CellViews are untouched (default 0 keeps every existing visibility test bit-identical). - The seal/punch fans (DrawRetailPViewPortalDepthWrite) lift their world verts to the drawn shell's space. - One shared constant PortalVisibilityBuilder.ShellDrawLiftZ feeds the shell registration (GameWindow:5604), the gate, and the fans. Register: AP-32 ADDED - the +0.02 lift had NO row (a pre-register deviation the 2026-06-12 sweep missed). The row records the split invariant both ways: a draw-space consumer that forgets the lift re-opens the #130 strip; a visibility consumer that picks the lifted transform re-opens the #119-residual side-cull. Pins: the lifted gate covers the drawn (lifted) aperture to 0.00 px across the 147-combo sweep; the unlifted gate shows the 6.7 px strip (sensitivity proof - if the lift is ever removed, this test says the drawLiftZ plumbing can go too). Suites: App 257+1skip / Core 1439+2skip / UI 420 / Net 294 green. Awaiting the user re-gate at a doorway with the lintel on screen. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
435 lines
22 KiB
C#
435 lines
22 KiB
C#
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 is 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 (BeginDoorwayScissor) on the slice AABB on
|
|
/// top. Every one of those passes can only SHRINK the gate, so any shave shows
|
|
/// as a strip of clear color between the gate's top edge and the aperture's
|
|
/// rasterized top edge (the shell wall starts above it; the seal z-kills
|
|
/// everything beyond; nothing re-covers).
|
|
///
|
|
/// This harness measures that 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 gate admits them.
|
|
/// Plane-gap and scissor-gap are measured separately (mechanism attribution).
|
|
///
|
|
/// VERDICT (2026-06-12, 147 eye/gaze combos): the CPU polygon pipeline is
|
|
/// sub-pixel exact (worst 0.54 px) — the W=0 clip port 987313a and both merge
|
|
/// passes are EXONERATED. The strip was the scissor box: the old
|
|
/// Floor(origin)+Ceiling(size) form cut up to 1 px off the TOP/RIGHT edges at
|
|
/// unlucky fractional alignments (captured live by this harness: top edge
|
|
/// y=0.7938 at 1080p → row 968 cut; right edge x=0.3503 at 1920 → column 1296
|
|
/// cut). Fixed by the conservative NdcScissorRect bound; the assertions below
|
|
/// pin both properties.
|
|
/// </summary>
|
|
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 Diagnostic_ExitDoorTopEdge_GateVsAperture()
|
|
{
|
|
var datDir = CornerFloodReplayTests.ResolveDatDir();
|
|
if (datDir is null) { _out.WriteLine("SKIP: dats unavailable"); return; }
|
|
|
|
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];
|
|
// DRAWN space: the shell that rasterizes the aperture (and the seal fan)
|
|
// draws +ShellDrawLiftZ above the physics transform — the gate must be
|
|
// compared against the drawn hole, not the physics polygon (#130: the
|
|
// unlifted gate left a 2 cm background strip under the drawn lintel).
|
|
var worldPoly = new Vector3[localPoly.Length];
|
|
for (int i = 0; i < localPoly.Length; i++)
|
|
{
|
|
worldPoly[i] = Vector3.Transform(localPoly[i], root.WorldTransform);
|
|
worldPoly[i].Z += PortalVisibilityBuilder.ShellDrawLiftZ;
|
|
}
|
|
|
|
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, worstScissorGapPx = 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, drawLiftZ: PortalVisibilityBuilder.ShellDrawLiftZ);
|
|
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 scissorGapPx, float atX) =
|
|
MeasureTopEdgeGap(aperture, asm.OutsideViewSlices, 1920, 1080);
|
|
|
|
if (planeGapPx > worstPlaneGapPx || scissorGapPx > worstScissorGapPx)
|
|
{
|
|
worstDesc = FormattableString.Invariant(
|
|
$"d={d} h={h} lat={lat} gz={gz} minW={minW:F2} atX={atX:F3} slices={asm.OutsideViewSlices.Length} mode={asm.TerrainMode} outVerts={DescribePolys(pv.OutsideView)} apVerts={aperture.Length}");
|
|
worstPlaneGapPx = MathF.Max(worstPlaneGapPx, planeGapPx);
|
|
worstScissorGapPx = MathF.Max(worstScissorGapPx, scissorGapPx);
|
|
}
|
|
|
|
if (planeGapPx > 0.55f || scissorGapPx > 0.55f)
|
|
{
|
|
_out.WriteLine(FormattableString.Invariant(
|
|
$"GAP d={d} h={h} lat={lat} gz={gz}: planeGap={planeGapPx:F2}px scissorGap={scissorGapPx:F2}px atX={atX:F3} mode={asm.TerrainMode} 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} worstScissorGapPx={worstScissorGapPx:F2} @ {worstDesc}"));
|
|
|
|
Assert.True(evaluated > 100, $"sweep degenerated: only {evaluated} eye/gaze combos evaluated");
|
|
// PIN 1 (#130): the scissor box never cuts a fragment the plane gate
|
|
// admits — conservative containment (AD-17's over-include doctrine).
|
|
// One probe step is ~0.11 px; anything beyond it is a real cut row.
|
|
Assert.True(worstScissorGapPx <= 0.15f, FormattableString.Invariant(
|
|
$"scissor under-covers the plane-admitted region by {worstScissorGapPx:F2}px @ {worstDesc}"));
|
|
// PIN 2 (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}"));
|
|
}
|
|
|
|
/// <summary>Sensitivity proof + regression documentation: a gate built in
|
|
/// PHYSICS space (drawLiftZ 0) against the DRAWN (lifted) aperture shows a
|
|
/// multi-pixel strip at a close doorway — the user-visible #130 strip
|
|
/// (f35cb8b split the lift out of the visibility transform; the OutsideView
|
|
/// kept gating drawn color in unlifted space). If this stops failing-by-gap,
|
|
/// the lift is gone and the production drawLiftZ plumbing can go too.</summary>
|
|
[Fact]
|
|
public void UnliftedGate_LeavesTheStripAtTheDrawnTopEdge()
|
|
{
|
|
var datDir = CornerFloodReplayTests.ResolveDatDir();
|
|
if (datDir is null) { _out.WriteLine("SKIP: dats unavailable"); return; }
|
|
|
|
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;
|
|
|
|
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);
|
|
|
|
var localPoly = root.PortalPolygons[exitIdx];
|
|
var worldPoly = new Vector3[localPoly.Length];
|
|
Vector3 centroid = Vector3.Zero;
|
|
for (int i = 0; i < localPoly.Length; i++)
|
|
{
|
|
worldPoly[i] = Vector3.Transform(localPoly[i], root.WorldTransform);
|
|
worldPoly[i].Z += PortalVisibilityBuilder.ShellDrawLiftZ; // drawn space
|
|
centroid += worldPoly[i];
|
|
}
|
|
centroid /= worldPoly.Length;
|
|
|
|
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);
|
|
|
|
// d=2.4 m, eye low (0.9 m above the opening's base), gaze at the
|
|
// centroid — the main sweep's clean case, where the aperture top edge
|
|
// projects ON SCREEN (y≈0.79; a closer/higher eye pushes the lintel
|
|
// past the screen top and the seam becomes unmeasurable).
|
|
var eye = centroid + worldNormal * 2.4f;
|
|
eye.Z = centroid.Z - 1.0f + 0.9f;
|
|
var viewProj = ViewProjFor(eye, centroid);
|
|
|
|
var clip = new Vector4[worldPoly.Length];
|
|
for (int i = 0; i < worldPoly.Length; i++)
|
|
clip[i] = Vector4.Transform(new Vector4(worldPoly[i], 1f), viewProj);
|
|
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 pvUnlifted = PortalVisibilityBuilder.Build(root, eye, Lookup, viewProj); // drawLiftZ 0
|
|
var asmUnlifted = ClipFrameAssembler.Assemble(ClipFrame.NoClip(), pvUnlifted);
|
|
Assert.True(asmUnlifted.OutsideViewSlices.Length > 0);
|
|
(float unliftedGapPx, _, _) = MeasureTopEdgeGap(aperture, asmUnlifted.OutsideViewSlices, 1920, 1080);
|
|
|
|
var pvLifted = PortalVisibilityBuilder.Build(root, eye, Lookup, viewProj,
|
|
buildingMembership: null, drawLiftZ: PortalVisibilityBuilder.ShellDrawLiftZ);
|
|
var asmLifted = ClipFrameAssembler.Assemble(ClipFrame.NoClip(), pvLifted);
|
|
Assert.True(asmLifted.OutsideViewSlices.Length > 0);
|
|
(float liftedGapPx, _, _) = MeasureTopEdgeGap(aperture, asmLifted.OutsideViewSlices, 1920, 1080);
|
|
|
|
_out.WriteLine(FormattableString.Invariant(
|
|
$"top-edge gap vs the DRAWN aperture at d=2.4 m: unliftedGate={unliftedGapPx:F2}px liftedGate={liftedGapPx:F2}px"));
|
|
var dbg = new System.Text.StringBuilder(" aperture(LIFTED):");
|
|
foreach (var v in aperture) dbg.Append(FormattableString.Invariant($" ({v.X:F4},{v.Y:F4})"));
|
|
_out.WriteLine(dbg.ToString());
|
|
foreach (var poly in pvUnlifted.OutsideView.Polygons)
|
|
{
|
|
var sb = new System.Text.StringBuilder(" unliftedGatePoly:");
|
|
foreach (var v in poly.Vertices) sb.Append(FormattableString.Invariant($" ({v.X:F4},{v.Y:F4})"));
|
|
_out.WriteLine(sb.ToString());
|
|
}
|
|
foreach (var poly in pvLifted.OutsideView.Polygons)
|
|
{
|
|
var sb = new System.Text.StringBuilder(" liftedGatePoly:");
|
|
foreach (var v in poly.Vertices) sb.Append(FormattableString.Invariant($" ({v.X:F4},{v.Y:F4})"));
|
|
_out.WriteLine(sb.ToString());
|
|
}
|
|
|
|
// The strip the user saw: physics-space gate vs drawn hole, several px.
|
|
Assert.True(unliftedGapPx > 2.0f, FormattableString.Invariant(
|
|
$"expected the unlifted gate to show the strip (>2px), got {unliftedGapPx:F2}px"));
|
|
// The fix: a gate in drawn space covers the drawn hole.
|
|
Assert.True(liftedGapPx <= 1.2f, FormattableString.Invariant(
|
|
$"lifted gate still under-covers by {liftedGapPx:F2}px"));
|
|
}
|
|
|
|
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 gate admits the
|
|
/// point. Returns the worst gaps in 1080p pixels (plane gate and modeled
|
|
/// scissor gate measured independently), and the x of the worst plane gap.
|
|
/// </summary>
|
|
private static (float planeGapPx, float scissorGapPx, float atX) MeasureTopEdgeGap(
|
|
Vector2[] aperture, ClipViewSlice[] slices, int fbW, 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, 0);
|
|
|
|
float worstPlane = 0, worstScissor = 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);
|
|
// The scissor question is "does the box cut pixels the PLANES would
|
|
// draw" — measure it from the planes-admitted top, not the aperture
|
|
// top (at slanted corners the aperture top can sit legitimately
|
|
// outside the gate polygon's column).
|
|
var pPlanes = new Vector2(p.X, p.Y - planeGap - Inset);
|
|
float scissorGap = GapBelow(pPlanes, q => AnySliceAdmitsScissor(slices, q, fbW, fbH), StepY, CapY);
|
|
|
|
if (debug is not null && scissorGap > 0.005f)
|
|
debug.WriteLine(FormattableString.Invariant(
|
|
$" sample x={x:F4} apTop={topY:F4} planeGap={planeGap * fbH / 2f:F2}px pPlanes=({pPlanes.X:F4},{pPlanes.Y:F4}) scissorGap={scissorGap * fbH / 2f:F2}px"));
|
|
|
|
if (planeGap > worstPlane) { worstPlane = planeGap; atX = x; }
|
|
worstScissor = MathF.Max(worstScissor, scissorGap);
|
|
}
|
|
// NDC y → pixels at the given framebuffer height.
|
|
return (worstPlane * fbH / 2f, worstScissor * 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 (scissor fallback) 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;
|
|
}
|
|
|
|
// Production scissor (BeginDoorwayScissor → NdcScissorRect.ToPixels): a
|
|
// point is admitted when its pixel falls inside some slice's scissor box.
|
|
private static bool AnySliceAdmitsScissor(ClipViewSlice[] slices, Vector2 p, int fbW, int fbH)
|
|
{
|
|
int pixX = (int)MathF.Floor((p.X * 0.5f + 0.5f) * fbW);
|
|
int pixY = (int)MathF.Floor((p.Y * 0.5f + 0.5f) * fbH);
|
|
foreach (var slice in slices)
|
|
{
|
|
var box = NdcScissorRect.ToPixels(slice.NdcAabb, fbW, fbH);
|
|
if (pixX >= box.X && pixX < box.X + box.Width
|
|
&& pixY >= box.Y && pixY < box.Y + box.Height)
|
|
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;
|
|
}
|
|
}
|