418 lines
16 KiB
C#
418 lines
16 KiB
C#
using System.Numerics;
|
||
using AcDream.App.Rendering.Gpu;
|
||
using AcDream.App.Rendering.Wb;
|
||
using AcDream.Core.Terrain;
|
||
|
||
namespace AcDream.App.Rendering;
|
||
|
||
/// <summary>
|
||
/// Phase N.5b modern terrain dispatcher. Single global vertex/index arena with
|
||
/// a slot allocator (one slot per landblock, 384 verts × 40 bytes = 15,360
|
||
/// bytes per slot). Per-frame: build a DrawElementsIndirectCommand array from
|
||
/// visible slots and dispatch via one multi-draw-indirect call. Atlas
|
||
/// textures bound via the device's global texture table.
|
||
///
|
||
/// <para>Campaign V slice V11 deleted the raw-GL submission arm
|
||
/// (<c>TerrainModernRenderer.cs</c>'s former GL fields/constructor/Draw/Dispose
|
||
/// bodies); the RHI arm this file now exclusively hosts the shared allocator
|
||
/// and visibility logic for is defined in <c>TerrainModernRenderer.Rhi.cs</c>.</para>
|
||
/// </summary>
|
||
public sealed partial class TerrainModernRenderer : IDisposable
|
||
{
|
||
// VertsPerLandblock MUST stay divisible by 6 — terrain_modern.vert uses
|
||
// `gl_VertexID % 6` to pick the cell-corner index (BL/BR/TR/TL), and
|
||
// because we bake `slot * VertsPerLandblock` into indices CPU-side and
|
||
// pass BaseVertex=0 to MultiDrawElementsIndirect, gl_VertexID becomes
|
||
// `slot * VertsPerLandblock + local_index`. The shader's modulo-6 only
|
||
// reduces to `local_index % 6` because 384 is a multiple of 6. Changing
|
||
// either constant without auditing the shader will silently mis-render.
|
||
private const int VertsPerLandblock = LandblockMesh.VerticesPerLandblock; // 384 (= 64 cells * 6 verts)
|
||
private const int IndicesPerLandblock = VertsPerLandblock;
|
||
private const int VertexSize = 40; // sizeof(TerrainVertex)
|
||
private const int IndexSize = sizeof(uint);
|
||
private const float LandblockSize = LandblockMesh.LandblockSize; // 192
|
||
|
||
private readonly TerrainAtlas _atlas;
|
||
|
||
/// <summary>A.5 T22.5: exposes the terrain atlas so callers can update
|
||
/// anisotropic level mid-session via <see cref="TerrainAtlas.SetAnisotropic"/>.</summary>
|
||
public TerrainAtlas Atlas => _atlas;
|
||
|
||
private readonly GpuRetiredTerrainSlotAllocator _alloc;
|
||
private readonly GpuRetirementLedger _retirementLedger;
|
||
private bool _disposed;
|
||
|
||
// Per-slot live data (index by slot integer; null entries are unused slots).
|
||
private SlotData?[] _slots;
|
||
|
||
// Reverse map: landblockId -> slot, for RemoveLandblock and replacement.
|
||
private readonly Dictionary<uint, int> _idToSlot = new();
|
||
|
||
// Backing-store capacity bookkeeping, shared with the RHI arm's arena.
|
||
private long _globalVboCapacityBytes;
|
||
private long _globalEboCapacityBytes;
|
||
|
||
// Per-GPU-fenced-frame-slot draw bookkeeping, shared with the RHI arm.
|
||
private int _dynamicFrameSlot;
|
||
private bool _dynamicFrameStarted;
|
||
|
||
/// <summary>
|
||
/// The dynamic per-frame-slot indirect-command buffer pool this used to
|
||
/// report was raw-GL-only bookkeeping, deleted with that arm at Campaign V
|
||
/// slice V11. The RHI arm allocates its indirect-command storage from the
|
||
/// GPU frame's own upload ring instead, so there is no separate pool to
|
||
/// count.
|
||
/// </summary>
|
||
internal int DynamicIndirectBufferCount => 0;
|
||
|
||
// 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();
|
||
|
||
/// <summary>
|
||
/// Resets the per-GPU-fenced-frame-slot draw state. A retail outside view
|
||
/// may draw terrain more than once in a frame.
|
||
/// </summary>
|
||
public void BeginFrame(int frameSlot)
|
||
{
|
||
ArgumentOutOfRangeException.ThrowIfNegative(frameSlot);
|
||
if (_directionalShadowFrameSequence == long.MaxValue)
|
||
throw new InvalidOperationException(
|
||
"Directional-shadow terrain frame identity was exhausted.");
|
||
_directionalShadowFrameSequence++;
|
||
_retirementLedger.RetryPendingPublications();
|
||
_dynamicFrameSlot = frameSlot;
|
||
_dynamicFrameStarted = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Two-tier streaming entry point. Accepts a prebuilt mesh from
|
||
/// <see cref="LandblockStreamResult.Loaded.MeshData"/> built on the worker
|
||
/// thread, together with the world-space origin computed by the caller
|
||
/// (render-thread GameWindow derives it from landblockId + liveCenterX/Y).
|
||
///
|
||
/// Delegates to <see cref="AddLandblock(uint,LandblockMeshData,Vector3)"/>
|
||
/// so both paths share one upload path. Per Phase A.5 spec T15.
|
||
/// </summary>
|
||
public void AddLandblockWithMesh(uint landblockId, LandblockMeshData meshData, Vector3 worldOrigin)
|
||
=> AddLandblock(landblockId, meshData, worldOrigin);
|
||
|
||
public void AddLandblock(uint landblockId, LandblockMeshData meshData, Vector3 worldOrigin)
|
||
{
|
||
ArgumentNullException.ThrowIfNull(meshData);
|
||
if (meshData.Vertices.Length != VertsPerLandblock)
|
||
throw new ArgumentException(
|
||
$"Expected {VertsPerLandblock} vertices, got {meshData.Vertices.Length}",
|
||
nameof(meshData));
|
||
if (meshData.Indices.Length != IndicesPerLandblock)
|
||
throw new ArgumentException(
|
||
$"Expected {IndicesPerLandblock} indices, got {meshData.Indices.Length}",
|
||
nameof(meshData));
|
||
|
||
// A prior replacement may have committed the logical slot switch
|
||
// before queue publication failed. Retry those retained physical-slot
|
||
// transactions before allocating more terrain storage.
|
||
_alloc.RetryPendingPublications();
|
||
|
||
bool replacing = _idToSlot.TryGetValue(landblockId, out int replacedSlot);
|
||
int slot = _alloc.Allocate(out var needsGrow);
|
||
bool published = false;
|
||
try
|
||
{
|
||
if (needsGrow)
|
||
{
|
||
int newCap = Math.Max(_alloc.Capacity * 2, slot + 1);
|
||
EnsureCapacity(newCap);
|
||
}
|
||
|
||
// Bake worldOrigin into vertex positions; capture min/max Z for AABB.
|
||
var bakedVerts = new TerrainVertex[VertsPerLandblock];
|
||
float zMin = float.MaxValue, zMax = float.MinValue;
|
||
for (int i = 0; i < VertsPerLandblock; i++)
|
||
{
|
||
var v = meshData.Vertices[i];
|
||
var worldPos = v.Position + worldOrigin;
|
||
bakedVerts[i] = new TerrainVertex(worldPos, v.Normal, v.Data0, v.Data1, v.Data2, v.Data3);
|
||
if (worldPos.Z < zMin) zMin = worldPos.Z;
|
||
if (worldPos.Z > zMax) zMax = worldPos.Z;
|
||
}
|
||
if (zMin == float.MaxValue) { zMin = 0f; zMax = 0f; }
|
||
|
||
// Bake baseVertex into indices on the CPU side (driver-portable pattern).
|
||
uint baseVertex = (uint)(slot * VertsPerLandblock);
|
||
var bakedIndices = new uint[IndicesPerLandblock];
|
||
for (int i = 0; i < IndicesPerLandblock; i++)
|
||
bakedIndices[i] = meshData.Indices[i] + baseVertex;
|
||
|
||
UploadRhiLandblock(slot, bakedVerts, bakedIndices);
|
||
|
||
_slots[slot] = new SlotData
|
||
{
|
||
LandblockId = landblockId,
|
||
WorldOrigin = worldOrigin,
|
||
FirstIndex = (uint)(slot * IndicesPerLandblock),
|
||
IndexCount = IndicesPerLandblock,
|
||
AabbMin = new Vector3(worldOrigin.X, worldOrigin.Y, zMin),
|
||
AabbMax = new Vector3(worldOrigin.X + LandblockSize, worldOrigin.Y + LandblockSize, zMax),
|
||
};
|
||
_idToSlot[landblockId] = slot;
|
||
published = true;
|
||
|
||
if (replacing)
|
||
{
|
||
_slots[replacedSlot] = null;
|
||
_alloc.FreeAfterGpuUse(replacedSlot);
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
if (!published)
|
||
_alloc.ReleaseUnsubmitted(slot);
|
||
}
|
||
}
|
||
|
||
public void RemoveLandblock(uint landblockId)
|
||
{
|
||
// Removal clears the logical lookup before retirement publication. A
|
||
// retry therefore has to advance retained publications even when the
|
||
// landblock is no longer present in the map.
|
||
_alloc.RetryPendingPublications();
|
||
if (!_idToSlot.TryGetValue(landblockId, out var slot))
|
||
return;
|
||
_idToSlot.Remove(landblockId);
|
||
_slots[slot] = null;
|
||
_alloc.FreeAfterGpuUse(slot);
|
||
// No GPU clear: the per-frame DEIC array won't reference this slot.
|
||
}
|
||
|
||
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++)
|
||
{
|
||
var data = _slots[slot];
|
||
if (data is null) continue;
|
||
if (frustum is not null && data.LandblockId != neverCullLandblockId)
|
||
{
|
||
if (!FrustumCuller.IsAabbVisible(frustum.Value, data.AabbMin, data.AabbMax))
|
||
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;
|
||
|
||
BuildIndirectCommands();
|
||
if (!_dynamicFrameStarted)
|
||
throw new InvalidOperationException("BeginFrame must be called before drawing terrain.");
|
||
DrawRhi(viewProjection, _visibleSlots.Count);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Builds this frame's <c>DrawElementsIndirectCommand</c> array from the
|
||
/// visible slot list. Pure CPU.
|
||
/// </summary>
|
||
private void BuildIndirectCommands()
|
||
{
|
||
if (_deicScratch.Length < _visibleSlots.Count)
|
||
_deicScratch = new DrawElementsIndirectCommand[Math.Max(_visibleSlots.Count, 64)];
|
||
for (int i = 0; i < _visibleSlots.Count; i++)
|
||
{
|
||
var data = _slots[_visibleSlots[i]]!;
|
||
_deicScratch[i] = new DrawElementsIndirectCommand
|
||
{
|
||
Count = (uint)data.IndexCount,
|
||
InstanceCount = 1u,
|
||
FirstIndex = data.FirstIndex,
|
||
BaseVertex = 0, // baked into indices on upload
|
||
BaseInstance = 0,
|
||
};
|
||
}
|
||
}
|
||
|
||
public void Dispose()
|
||
{
|
||
if (_disposed)
|
||
return;
|
||
_retirementLedger.RetryPendingPublications();
|
||
DisposeRhi();
|
||
}
|
||
|
||
// ----------------------------------------------------------------
|
||
// Private helpers
|
||
// ----------------------------------------------------------------
|
||
|
||
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;
|
||
EnsureRhiCapacity(newCapacity);
|
||
}
|
||
|
||
private sealed class SlotData
|
||
{
|
||
public uint LandblockId;
|
||
public Vector3 WorldOrigin;
|
||
public uint FirstIndex;
|
||
public int IndexCount;
|
||
public Vector3 AabbMin;
|
||
public Vector3 AabbMax;
|
||
}
|
||
}
|