perf(vfx): port retail particle visibility degradation

Resolve DAT-authored particle ranges from the hardware GfxObj, apply retail distance and completed-cell visibility gates, and preserve the exact finite/infinite off-view update semantics. This removes dense-world simulation work without shortening terrain, entity, fog, or streaming distance.

Publish doorway-clipped outdoor cells through a focused frame controller, retain effect cell identity for outdoor statics, reject hidden emitters before particle-slot scans, and offer an explicit opt-in Extended particle range.

Release build succeeds and all 5,857 tests pass with five intentional skips. Retail-conformance, architecture, and adversarial review cycles are clean; connected Aerlinthe visual/performance gate pending.

Co-authored-by: OpenAI Codex <codex@openai.com>

src/AcDream.App/Rendering/TerrainModernRenderer.cs

@@ -69,12 +69,21 @@ public sealed unsafe class TerrainModernRenderer : IDisposable
 
     // Reusable per-frame buffers.
     private readonly List<int> _visibleSlots = new();
+    private readonly HashSet<uint> _visibleCellIds = new();
     private DrawElementsIndirectCommand[] _deicScratch = Array.Empty<DrawElementsIndirectCommand>();
 
     // Diag.
     public int LoadedSlots   => _alloc.LoadedCount;
     public int VisibleSlots  => _visibleSlots.Count;
     public int CapacitySlots => _alloc.Capacity;
+    /// <summary>
+    /// Outdoor landcells admitted by the current landscape view. The set is
+    /// accumulated across doorway landscape slices and consumed after the
+    /// completed render frame by particle visibility.
+    /// </summary>
+    internal HashSet<uint> VisibleCellIds => _visibleCellIds;
+
+    public void BeginVisibilityFrame() => _visibleCellIds.Clear();
 
     public TerrainModernRenderer(
         GL gl,
@@ -208,10 +217,17 @@ public sealed unsafe class TerrainModernRenderer : IDisposable
         // No GPU clear: the per-frame DEIC array won't reference this slot.
     }
 
-    public void Draw(ICamera camera, FrustumPlanes? frustum = null, uint? neverCullLandblockId = null)
+    public void Draw(
+        ICamera camera,
+        FrustumPlanes? frustum = null,
+        uint? neverCullLandblockId = null,
+        ReadOnlySpan<Vector4> clipPlanes = default,
+        Vector4? ndcClipAabb = null)
     {
         if (_alloc.LoadedCount == 0) return;
 
+        Matrix4x4 viewProjection = camera.View * camera.Projection;
+
         // Build visible slot list with per-slot frustum cull.
         _visibleSlots.Clear();
         for (int slot = 0; slot < _slots.Length; slot++)
@@ -224,6 +240,16 @@ public sealed unsafe class TerrainModernRenderer : IDisposable
                     continue;
             }
             _visibleSlots.Add(slot);
+            CollectVisibleCells(
+                _visibleCellIds,
+                data.LandblockId,
+                data.WorldOrigin,
+                data.AabbMin.Z,
+                data.AabbMax.Z,
+                frustum,
+                viewProjection,
+                clipPlanes,
+                ndcClipAabb);
         }
         if (_visibleSlots.Count == 0) return;
 
@@ -436,6 +462,130 @@ public sealed unsafe class TerrainModernRenderer : IDisposable
         _gl.BindVertexArray(0);
     }
 
+    internal static void CollectVisibleCells(
+        HashSet<uint> destination,
+        uint landblockId,
+        Vector3 worldOrigin,
+        float zMin,
+        float zMax,
+        FrustumPlanes? frustum,
+        Matrix4x4 viewProjection,
+        ReadOnlySpan<Vector4> clipPlanes,
+        Vector4? ndcClipAabb = null)
+    {
+        ArgumentNullException.ThrowIfNull(destination);
+        const float cellSize = AcDream.Core.Physics.TerrainSurface.CellSize;
+        const int cellsPerSide = AcDream.Core.Physics.TerrainSurface.CellsPerSide;
+        uint prefix = landblockId & 0xFFFF0000u;
+
+        for (int cellX = 0; cellX < cellsPerSide; cellX++)
+        {
+            float minX = worldOrigin.X + cellX * cellSize;
+            float maxX = minX + cellSize;
+            for (int cellY = 0; cellY < cellsPerSide; cellY++)
+            {
+                float minY = worldOrigin.Y + cellY * cellSize;
+                float maxY = minY + cellSize;
+                var cellMin = new Vector3(minX, minY, zMin);
+                var cellMax = new Vector3(maxX, maxY, zMax);
+                if (frustum is not null
+                    && !FrustumCuller.IsAabbVisible(frustum.Value, cellMin, cellMax))
+                {
+                    continue;
+                }
+
+                // Retail publishes landcell in_view from the clipped landscape
+                // view, not merely from the camera frustum. The modern renderer
+                // expresses each doorway slice as homogeneous clip-space planes
+                // plus its scissor AABB; use both products here so particle
+                // simulation follows the same visible terrain slice as the GPU.
+                if (!IsAabbVisibleThroughClipRegion(
+                        cellMin,
+                        cellMax,
+                        viewProjection,
+                        clipPlanes,
+                        ndcClipAabb))
+                {
+                    continue;
+                }
+
+                uint low = AcDream.Core.Physics.TerrainSurface.ComputeOutdoorCellLowId(
+                    cellX * cellSize,
+                    cellY * cellSize);
+                destination.Add(prefix | low);
+            }
+        }
+    }
+
+    private static bool IsAabbVisibleThroughClipRegion(
+        Vector3 min,
+        Vector3 max,
+        Matrix4x4 viewProjection,
+        ReadOnlySpan<Vector4> clipPlanes,
+        Vector4? ndcClipAabb)
+    {
+        Vector4 aabb = ndcClipAabb.GetValueOrDefault();
+        bool hasScissorConstraint = ndcClipAabb.HasValue
+            && (aabb.X > -1f || aabb.Y > -1f || aabb.Z < 1f || aabb.W < 1f);
+        if (clipPlanes.IsEmpty && !hasScissorConstraint)
+            return true;
+
+        Span<Vector4> clipCorners = stackalloc Vector4[8];
+        for (int corner = 0; corner < clipCorners.Length; corner++)
+        {
+            var world = new Vector4(
+                (corner & 1) == 0 ? min.X : max.X,
+                (corner & 2) == 0 ? min.Y : max.Y,
+                (corner & 4) == 0 ? min.Z : max.Z,
+                1f);
+            clipCorners[corner] = Vector4.Transform(world, viewProjection);
+        }
+
+        for (int planeIndex = 0; planeIndex < clipPlanes.Length; planeIndex++)
+        {
+            if (IsAabbOutsideHomogeneousPlane(clipCorners, clipPlanes[planeIndex]))
+            {
+                return false;
+            }
+        }
+
+        if (!hasScissorConstraint)
+            return true;
+
+        Span<Vector4> scissorPlanes = stackalloc Vector4[4]
+        {
+            new( 1f,  0f, 0f, -aabb.X),
+            new(-1f,  0f, 0f,  aabb.Z),
+            new( 0f,  1f, 0f, -aabb.Y),
+            new( 0f, -1f, 0f,  aabb.W),
+        };
+        for (int planeIndex = 0; planeIndex < scissorPlanes.Length; planeIndex++)
+        {
+            if (IsAabbOutsideHomogeneousPlane(clipCorners, scissorPlanes[planeIndex]))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static bool IsAabbOutsideHomogeneousPlane(
+        ReadOnlySpan<Vector4> clipCorners,
+        Vector4 plane)
+    {
+        // A linear half-space reaches its maximum over the transformed AABB at
+        // one of the eight corners. If every corner is negative, no point in
+        // the cell box can survive this GPU clip plane.
+        for (int corner = 0; corner < clipCorners.Length; corner++)
+        {
+            if (Vector4.Dot(plane, clipCorners[corner]) >= 0f)
+                return false;
+        }
+
+        return true;
+    }
+
     private void EnsureCapacity(int newCapacity)
     {
         if (newCapacity <= _alloc.Capacity) return;