76 lines
2.8 KiB
C#
76 lines
2.8 KiB
C#
namespace Age.Engine.Hosting;
|
|
|
|
/// <summary>Host-owned virtual clock. Godot advances it from real elapsed time; VM pacing, sleeps, and
|
|
/// retained graphics all consume this same timebase. Fractional milliseconds are retained so diagnostic
|
|
/// slow motion does not stall on high-refresh displays.</summary>
|
|
public sealed class FrameClock
|
|
{
|
|
private long _nowMs;
|
|
private double _fractionalMs;
|
|
|
|
/// <summary>Monotonic virtual time in milliseconds (scaled by Speed).</summary>
|
|
public long NowMs => System.Threading.Interlocked.Read(ref _nowMs);
|
|
|
|
/// <summary>Speed multiplier. 1.0 = normal. A lower diagnostic value slows VM progress, sleeps, and
|
|
/// graphics together; a future ADV-scoped Ctrl hook can drive the same seam.</summary>
|
|
public double Speed = 1.0;
|
|
|
|
/// <summary>Native normal-playback interpreter cadence. The old 1,800 figure counted calls to
|
|
/// vm_operand_fetch, not completed opcodes. A live 1,890 ms transform section executes about 407
|
|
/// port opcodes. A normal-speed replay at 215/s retained the object for 1,798 ms; 200/s reaches
|
|
/// the native 1,890 ms endpoint before the same teardown path.</summary>
|
|
public double OpsPerSecond = 200.0;
|
|
|
|
/// <summary>Advance the clock by one rendered frame's real delta (seconds), scaled by Speed.</summary>
|
|
public void Advance(double realDeltaSeconds)
|
|
{
|
|
double scaled = realDeltaSeconds * 1000.0 * Speed + _fractionalMs;
|
|
long whole = (long)System.Math.Floor(scaled);
|
|
_fractionalMs = scaled - whole;
|
|
if (whole > 0) System.Threading.Interlocked.Add(ref _nowMs, whole);
|
|
}
|
|
}
|
|
|
|
/// <summary>Pure wall-clock opcode rate limiter. The VM thread records completed opcodes and waits whenever
|
|
/// it has consumed the allowance earned from <see cref=FrameClock.NowMs/>. Reset after a blocking wait so
|
|
/// parked time never turns into a catch-up burst.</summary>
|
|
public sealed class WallClockOpPacer
|
|
{
|
|
private readonly FrameClock _clock;
|
|
private bool _started;
|
|
private long _epochMs;
|
|
private long _completed;
|
|
|
|
public WallClockOpPacer(FrameClock clock) => _clock = clock;
|
|
|
|
public void OpcodeCompleted()
|
|
{
|
|
if (!_started)
|
|
{
|
|
_started = true;
|
|
_epochMs = _clock.NowMs;
|
|
_completed = 0;
|
|
}
|
|
_completed++;
|
|
}
|
|
|
|
/// <summary>Whether the next opcode may execute at the clock's current time.</summary>
|
|
public bool CanRunNext
|
|
{
|
|
get
|
|
{
|
|
if (!_started) return true;
|
|
long elapsed = System.Math.Max(0, _clock.NowMs - _epochMs);
|
|
long allowance = 1 + (long)System.Math.Floor(elapsed * _clock.OpsPerSecond / 1000.0);
|
|
return _completed < allowance;
|
|
}
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
_started = false;
|
|
_epochMs = 0;
|
|
_completed = 0;
|
|
}
|
|
}
|