9ec83307fc
The clip predicate (w+z>=0) is convention-agnostic, not GL-specific: Matrix4x4.CreatePerspectiveFieldOfView (which all acdream cameras use) is NDC z in [0,1], not [-1,1]. Comment said "GL near plane / z_ndc>=-1" which is misleading though the code is correct (eye w=0 always excluded; divide safe under both conventions). Also soften the ProjectToNdc CCW claim: it preserves projected winding; the caller must feed camera-facing portals. No behavior change. (Opus code-review I-1/M-1.) Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
81 lines
3.3 KiB
C#
81 lines
3.3 KiB
C#
// 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).
|
|
using System.Collections.Generic;
|
|
using System.Numerics;
|
|
|
|
namespace AcDream.App.Rendering;
|
|
|
|
public static class PortalProjection
|
|
{
|
|
/// <summary>Project a cell-local polygon to NDC, preserving the projected winding of
|
|
/// the input (NOT normalized to CCW). The caller (PortalVisibilityBuilder) is responsible
|
|
/// for feeding camera-facing portal polygons (via the portal-side test) so the result is
|
|
/// CCW for the CCW-only <see cref="ScreenPolygonClip"/>. Returns fewer than 3 verts when
|
|
/// the polygon is entirely behind the camera / degenerate.</summary>
|
|
public static Vector2[] ProjectToNdc(IReadOnlyList<Vector3> localPoly, Matrix4x4 cellToWorld, Matrix4x4 viewProj)
|
|
{
|
|
if (localPoly == null || localPoly.Count < 3) return System.Array.Empty<Vector2>();
|
|
|
|
Matrix4x4 m = cellToWorld * viewProj;
|
|
|
|
// To clip space (keep w).
|
|
var clip = new List<Vector4>(localPoly.Count);
|
|
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);
|
|
if (clip.Count < 3) return System.Array.Empty<Vector2>();
|
|
|
|
// Perspective divide → NDC xy.
|
|
var ndc = new Vector2[clip.Count];
|
|
for (int i = 0; i < clip.Count; i++)
|
|
{
|
|
float w = clip[i].W;
|
|
ndc[i] = new Vector2(clip[i].X / w, clip[i].Y / w);
|
|
}
|
|
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)
|
|
{
|
|
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;
|
|
bool curIn = dCur >= 0f;
|
|
bool prevIn = dPrev >= 0f;
|
|
|
|
if (curIn)
|
|
{
|
|
if (!prevIn) result.Add(Lerp(prev, cur, dPrev, dCur));
|
|
result.Add(cur);
|
|
}
|
|
else if (prevIn)
|
|
{
|
|
result.Add(Lerp(prev, cur, dPrev, dCur));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static Vector4 Lerp(Vector4 p, Vector4 q, float dp, float dq)
|
|
{
|
|
float t = dp / (dp - dq);
|
|
return p + t * (q - p);
|
|
}
|
|
}
|