erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

fix(render): doorway void — portal near-clip was near-dependent (eye-clip instead)

Browse source 
The cottage doorway 'void' (dark cell + floating entities while the chase camera looks
through the opening): PortalProjection.ProjectToNdc clipped portals on w+z>=0 — the GL
[-1,1] near-plane test — but acdream's camera builds its projection with D3D-convention
Matrix4x4.CreatePerspectiveFieldOfView and a 1.0 m near plane (RetailChaseCamera). Against
that matrix w+z>=0 discards everything within ~0.5 m of the eye, so when the camera orbits
to ~0.1 m from a doorway portal the near edge is clipped, the far edge projects off-screen
([flap] showed p->0171 D=0.10 proj=4 clip=0 ndc Y=-3.5..-6.6), the room behind is culled
(vis=1) and only the tiny vestibule shell draws -> dark void. Rotating away moved the eye
off the portal -> vis=5 -> room rendered.

Fix: clip against the EYE (w > MinW, MinW=0.05 m), near-INDEPENDENT — a portal you're
standing in still projects (covers the screen) so the cell behind stays visible. We only
use the projected x/y for the visibility clip region, so keeping vertices in front of the
near plane is correct. Matches retail PView::GetClip near-clipping the portal before project.
RED->GREEN regression test (doorway 0.1 m from a near=1.0 eye); 177 App tests green; the
existing straddling ±50 bound still holds.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Erik 2026-06-03 13:42:46 +02:00
parent 1e9a9cab8c
commit 0cc561c4d0
2 changed files with 61 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

45
src/AcDream.App/Rendering/PortalProjection.cs
View file

@ -1,15 +1,20 @@
// PortalProjection.cs
//
// Phase A8.F: project a cell-local portal polygon to NDC screen space, clipping
// against the in-front-of-camera half-space (keep where w + z >= 0) so a portal
// straddling the camera does not invert under the perspective divide. This crossing
// excludes the eye (w = 0) and lands just in front of the near plane, so every kept
// vertex has w bounded away from zero and the divide is safe — no eye-singularity
// blow-up. The predicate is convention-agnostic: acdream's cameras build projection
// with Matrix4x4.CreatePerspectiveFieldOfView (NDC z in [0,1]); under a true GL
// [-1,1] matrix w + z = 0 is exactly the near plane. Either way the eye is excluded.
// Homogeneous form of the near-plane sidedness in retail PView::GetClip /
// ConstructView(CBldPortal) (decomp:432344 / 433832).
// Phase A8.F: project a cell-local portal polygon to NDC screen space, clipping against the
// IN-FRONT-OF-EYE half-space (keep where w > MinW) so a portal straddling the camera does not
// invert under the perspective divide, and the divide stays bounded away from the w=0 eye
// singularity.
//
// The clip is NEAR-INDEPENDENT on purpose. We only use the projected x/y for the visibility clip
// REGION, so a vertex in front of the eye is meaningful even if it is closer than the projection's
// near plane. acdream's cameras build projection with Matrix4x4.CreatePerspectiveFieldOfView (D3D
// convention, NDC z in [0,1]) and a 1.0 m near plane (RetailChaseCamera). The previous w+z>=0
// predicate was the GL ([-1,1]) near-plane test; against the D3D matrix it discarded everything
// within ~0.5 m of the eye, so a doorway the chase camera was ~0.1 m from got clipped to empty ->
// the cell behind it was culled -> the cottage doorway "void" (2026-06-03). Clipping at the eye
// (w > MinW) keeps a portal you're standing in (it covers the screen) so the cell behind stays
// visible. Retail PView::GetClip / ConstructView(CBldPortal) (decomp:432344 / 433832) near-clip the
// portal poly likewise before projecting.
using System.Collections.Generic;
using System.Numerics;
@ -33,8 +38,10 @@ public static class PortalProjection
foreach (var lp in localPoly)
clip.Add(Vector4.Transform(new Vector4(lp, 1f), m));
// Clip against the in-front-of-camera half-space (keep where w + z >= 0).
clip = ClipAgainstNearPlane(clip);
// Clip against the in-front-of-eye half-space (keep where w > MinW). Near-independent:
// see the file header — clipping at the projection's near plane culls portals the camera
// is standing in (the doorway "void").
clip = ClipBehindEye(clip);
if (clip.Count < 3) return System.Array.Empty<Vector2>();
// Perspective divide → NDC xy.
@ -47,16 +54,22 @@ public static class PortalProjection
return ndc;
}
// Sutherland-Hodgman against the in-front-of-camera half-space: keep where (w + z) >= 0.
private static List<Vector4> ClipAgainstNearPlane(List<Vector4> poly)
// Minimum clip-space w (≈ metres in front of the eye) to keep a vertex. Excludes the eye
// (w=0) singularity and the ~5 cm right at it (bounding the perspective divide), but is
// INTENTIONALLY far closer than the projection's 1.0 m near plane so a doorway the camera is
// standing in still projects and the cell behind it stays visible. See the file header.
private const float MinW = 0.05f;
// Sutherland-Hodgman against the in-front-of-eye half-space: keep where w > MinW.
private static List<Vector4> ClipBehindEye(List<Vector4> poly)
{
var result = new List<Vector4>(poly.Count + 1);
for (int i = 0; i < poly.Count; i++)
{
Vector4 cur = poly[i];
Vector4 prev = poly[(i + poly.Count - 1) % poly.Count];
float dCur = cur.W + cur.Z;
float dPrev = prev.W + prev.Z;
float dCur = cur.W - MinW;
float dPrev = prev.W - MinW;
bool curIn = dCur >= 0f;
bool prevIn = dPrev >= 0f;