9bd4d1eed8
Populates the collision engine with TerrainSurface + CellSurface entries when landblocks stream in, removes them when they stream out. CellSurface vertices are transformed from cell-local to world space using EnvCell.Position orientation + origin. Phase B.2 (player movement mode) will call PhysicsEngine.Resolve() to get collision-validated positions before sending them to the server. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
113 lines
4.5 KiB
C#
113 lines
4.5 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using AcDream.Core.World;
|
||
|
||
namespace AcDream.App.Streaming;
|
||
|
||
/// <summary>
|
||
/// Called once per frame from <c>GameWindow.OnUpdate</c>. Owns the
|
||
/// <see cref="StreamingRegion"/> and uses delegates into
|
||
/// <see cref="LandblockStreamer"/> so tests can inject fakes. All work
|
||
/// happens on the render thread; the streamer itself is background.
|
||
///
|
||
/// <remarks>
|
||
/// Threading: not thread-safe. All calls must happen on the render thread.
|
||
/// </remarks>
|
||
/// </summary>
|
||
public sealed class StreamingController
|
||
{
|
||
private readonly Action<uint> _enqueueLoad;
|
||
private readonly Action<uint> _enqueueUnload;
|
||
private readonly Func<int, IReadOnlyList<LandblockStreamResult>> _drainCompletions;
|
||
private readonly Action<LoadedLandblock> _applyTerrain;
|
||
private readonly Action<uint>? _removeTerrain;
|
||
private readonly GpuWorldState _state;
|
||
private StreamingRegion? _region;
|
||
|
||
public int Radius { get; set; }
|
||
|
||
/// <summary>
|
||
/// Cap on completions drained per <see cref="Tick"/> call. The cap is
|
||
/// the GPU upload budget for one frame: terrain mesh + per-entity GfxObj
|
||
/// sub-mesh uploads + texture uploads for one landblock take a few ms;
|
||
/// applying 25 of them in a single frame produces a memory spike
|
||
/// (observed: out-of-memory crash on the 5×5 first-frame load).
|
||
///
|
||
/// <para>
|
||
/// 4 is the original async-streamer value; it spreads a 5×5 first-frame
|
||
/// load over ~7 frames (~116ms at 60fps), which is below the human
|
||
/// perception threshold. Spawn races that previously dropped entities
|
||
/// while landblocks were in flight are now handled by
|
||
/// <see cref="GpuWorldState"/>'s pending-spawn list, so spreading
|
||
/// completions doesn't lose any data.
|
||
/// </para>
|
||
/// </summary>
|
||
public int MaxCompletionsPerFrame { get; set; } = 4;
|
||
|
||
public StreamingController(
|
||
Action<uint> enqueueLoad,
|
||
Action<uint> enqueueUnload,
|
||
Func<int, IReadOnlyList<LandblockStreamResult>> drainCompletions,
|
||
Action<LoadedLandblock> applyTerrain,
|
||
GpuWorldState state,
|
||
int radius,
|
||
Action<uint>? removeTerrain = null)
|
||
{
|
||
_enqueueLoad = enqueueLoad;
|
||
_enqueueUnload = enqueueUnload;
|
||
_drainCompletions = drainCompletions;
|
||
_applyTerrain = applyTerrain;
|
||
_removeTerrain = removeTerrain;
|
||
_state = state;
|
||
Radius = radius;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Advance one frame. <paramref name="observerCx"/>/<paramref name="observerCy"/>
|
||
/// are landblock coordinates (0..255) of the current viewer — the camera
|
||
/// in offline mode, the server-sent player position in live.
|
||
/// </summary>
|
||
public void Tick(int observerCx, int observerCy)
|
||
{
|
||
// First-tick bootstrap: no region yet, so the whole visible window
|
||
// is a load diff.
|
||
if (_region is null)
|
||
{
|
||
_region = new StreamingRegion(observerCx, observerCy, Radius);
|
||
foreach (var id in _region.Visible)
|
||
_enqueueLoad(id);
|
||
}
|
||
else if (_region.CenterX != observerCx || _region.CenterY != observerCy)
|
||
{
|
||
var diff = _region.RecenterTo(observerCx, observerCy);
|
||
foreach (var id in diff.ToLoad) _enqueueLoad(id);
|
||
foreach (var id in diff.ToUnload) _enqueueUnload(id);
|
||
}
|
||
|
||
// Drain up to N completions per frame so a big diff doesn't spike
|
||
// GPU upload time. Remaining completions wait for the next frame.
|
||
var drained = _drainCompletions(MaxCompletionsPerFrame);
|
||
foreach (var result in drained)
|
||
{
|
||
switch (result)
|
||
{
|
||
case LandblockStreamResult.Loaded loaded:
|
||
_applyTerrain(loaded.Landblock);
|
||
_state.AddLandblock(loaded.Landblock);
|
||
break;
|
||
case LandblockStreamResult.Unloaded unloaded:
|
||
_state.RemoveLandblock(unloaded.LandblockId);
|
||
_removeTerrain?.Invoke(unloaded.LandblockId);
|
||
break;
|
||
case LandblockStreamResult.Failed failed:
|
||
Console.WriteLine(
|
||
$"streaming: load failed for 0x{failed.LandblockId:X8}: {failed.Error}");
|
||
break;
|
||
case LandblockStreamResult.WorkerCrashed crashed:
|
||
Console.WriteLine(
|
||
$"streaming: worker CRASHED: {crashed.Error}");
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|