725 lines
35 KiB
C#
725 lines
35 KiB
C#
|
|
||
|
|
using System;
|
||
|
|
using NUnit.Framework;
|
||
|
|
using System.Collections.Generic;
|
||
|
|
using UnityEngine;
|
||
|
|
|
||
|
|
namespace Mirror.Tests
|
||
|
|
{
|
||
|
|
// a simple snapshot with timestamp & interpolation
|
||
|
|
struct SimpleSnapshot : Snapshot
|
||
|
|
{
|
||
|
|
public double remoteTimestamp { get; set; }
|
||
|
|
public double localTimestamp { get; set; }
|
||
|
|
public double value;
|
||
|
|
|
||
|
|
public SimpleSnapshot(double remoteTimestamp, double localTimestamp, double value)
|
||
|
|
{
|
||
|
|
this.remoteTimestamp = remoteTimestamp;
|
||
|
|
this.localTimestamp = localTimestamp;
|
||
|
|
this.value = value;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SimpleSnapshot Interpolate(SimpleSnapshot from, SimpleSnapshot to, double t) =>
|
||
|
|
new SimpleSnapshot(
|
||
|
|
// interpolated snapshot is applied directly. don't need timestamps.
|
||
|
|
0, 0,
|
||
|
|
// lerp unclamped in case we ever need to extrapolate.
|
||
|
|
// atm SnapshotInterpolation never does.
|
||
|
|
Mathd.LerpUnclamped(from.value, to.value, t));
|
||
|
|
}
|
||
|
|
|
||
|
|
public class SnapshotInterpolationTests
|
||
|
|
{
|
||
|
|
// buffer for convenience so we don't have to create it manually each time
|
||
|
|
SortedList<double, SimpleSnapshot> buffer;
|
||
|
|
|
||
|
|
[SetUp]
|
||
|
|
public void SetUp()
|
||
|
|
{
|
||
|
|
buffer = new SortedList<double, SimpleSnapshot>();
|
||
|
|
}
|
||
|
|
|
||
|
|
[Test]
|
||
|
|
public void InsertIfNewEnough()
|
||
|
|
{
|
||
|
|
// inserting a first value should always work
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(1, 1, 0);
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(first, buffer);
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(1));
|
||
|
|
|
||
|
|
// insert before first should not work
|
||
|
|
SimpleSnapshot before = new SimpleSnapshot(0.5, 0.5, 0);
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(before, buffer);
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(1));
|
||
|
|
|
||
|
|
// insert after first should work
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(2, 2, 0);
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(second, buffer);
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(2));
|
||
|
|
Assert.That(buffer.Values[0], Is.EqualTo(first));
|
||
|
|
Assert.That(buffer.Values[1], Is.EqualTo(second));
|
||
|
|
|
||
|
|
// insert after second should work
|
||
|
|
SimpleSnapshot after = new SimpleSnapshot(2.5, 2.5, 0);
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(after, buffer);
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(3));
|
||
|
|
Assert.That(buffer.Values[0], Is.EqualTo(first));
|
||
|
|
Assert.That(buffer.Values[1], Is.EqualTo(second));
|
||
|
|
Assert.That(buffer.Values[2], Is.EqualTo(after));
|
||
|
|
}
|
||
|
|
|
||
|
|
// the 'ACB' problem:
|
||
|
|
// if we have a snapshot A at t=0 and C at t=2,
|
||
|
|
// we start interpolating between them.
|
||
|
|
// if suddenly B at t=1 comes in unexpectely,
|
||
|
|
// we should NOT suddenly steer towards B.
|
||
|
|
// => inserting between the first two snapshot should never be allowed
|
||
|
|
// in order to avoid all kinds of edge cases.
|
||
|
|
[Test]
|
||
|
|
public void InsertIfNewEnough_ACB_Problem()
|
||
|
|
{
|
||
|
|
SimpleSnapshot a = new SimpleSnapshot(0, 0, 0);
|
||
|
|
SimpleSnapshot b = new SimpleSnapshot(1, 1, 0);
|
||
|
|
SimpleSnapshot c = new SimpleSnapshot(2, 2, 0);
|
||
|
|
|
||
|
|
// insert A and C
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(a, buffer);
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(c, buffer);
|
||
|
|
|
||
|
|
// trying to insert B between the first two snapshots should fail
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(b, buffer);
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(2));
|
||
|
|
Assert.That(buffer.Values[0], Is.EqualTo(a));
|
||
|
|
Assert.That(buffer.Values[1], Is.EqualTo(c));
|
||
|
|
}
|
||
|
|
|
||
|
|
// the 'first is lagging' problem:
|
||
|
|
// server sends A, B.
|
||
|
|
// A is lagging behind by 2000ms for whatever reason.
|
||
|
|
// we get B first.
|
||
|
|
// B should remain the first snapshot, the lagging A should be dropped
|
||
|
|
[Test]
|
||
|
|
public void InsertIfNewEnough_FirstIsLagging_Problem()
|
||
|
|
{
|
||
|
|
SimpleSnapshot a = new SimpleSnapshot(0, 0, 0);
|
||
|
|
SimpleSnapshot b = new SimpleSnapshot(1, 1, 0);
|
||
|
|
|
||
|
|
// insert B. A is still delayed.
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(b, buffer);
|
||
|
|
|
||
|
|
// now the delayed A comes in.
|
||
|
|
// timestamp is before B though.
|
||
|
|
// but it should still be dropped.
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(a, buffer);
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(1));
|
||
|
|
Assert.That(buffer.Values[0], Is.EqualTo(b));
|
||
|
|
}
|
||
|
|
|
||
|
|
[Test]
|
||
|
|
public void HasAmountOlderThan_NotEnough()
|
||
|
|
{
|
||
|
|
// only add two
|
||
|
|
SimpleSnapshot a = new SimpleSnapshot(0, 0, 0);
|
||
|
|
SimpleSnapshot b = new SimpleSnapshot(1, 1, 0);
|
||
|
|
buffer.Add(a.remoteTimestamp, a);
|
||
|
|
buffer.Add(b.remoteTimestamp, b);
|
||
|
|
|
||
|
|
// shouldn't have more old enough than two
|
||
|
|
// because we don't have more than two
|
||
|
|
Assert.That(SnapshotInterpolation.HasAmountOlderThan(buffer, 0, 3), Is.False);
|
||
|
|
}
|
||
|
|
|
||
|
|
[Test]
|
||
|
|
public void HasAmountOlderThan_EnoughButNotOldEnough()
|
||
|
|
{
|
||
|
|
// add three
|
||
|
|
SimpleSnapshot a = new SimpleSnapshot(0, 0, 0);
|
||
|
|
SimpleSnapshot b = new SimpleSnapshot(1, 1, 0);
|
||
|
|
SimpleSnapshot c = new SimpleSnapshot(2, 2, 0);
|
||
|
|
buffer.Add(a.remoteTimestamp, a);
|
||
|
|
buffer.Add(b.remoteTimestamp, b);
|
||
|
|
buffer.Add(c.remoteTimestamp, c);
|
||
|
|
|
||
|
|
// check at time = 1.9, where third one would not be old enough.
|
||
|
|
Assert.That(SnapshotInterpolation.HasAmountOlderThan(buffer, 1.9, 3), Is.False);
|
||
|
|
}
|
||
|
|
|
||
|
|
[Test]
|
||
|
|
public void HasAmountOlderThan_EnoughAndOldEnough()
|
||
|
|
{
|
||
|
|
// add three
|
||
|
|
SimpleSnapshot a = new SimpleSnapshot(0, 0, 0);
|
||
|
|
SimpleSnapshot b = new SimpleSnapshot(1, 1, 0);
|
||
|
|
SimpleSnapshot c = new SimpleSnapshot(2, 2, 0);
|
||
|
|
buffer.Add(a.remoteTimestamp, a);
|
||
|
|
buffer.Add(b.remoteTimestamp, b);
|
||
|
|
buffer.Add(c.remoteTimestamp, c);
|
||
|
|
|
||
|
|
// check at time = 2.1, where third one would be old enough.
|
||
|
|
Assert.That(SnapshotInterpolation.HasAmountOlderThan(buffer, 2.1, 3), Is.True);
|
||
|
|
}
|
||
|
|
|
||
|
|
// UDP messages might arrive twice sometimes.
|
||
|
|
// make sure InsertIfNewEnough can handle it.
|
||
|
|
[Test]
|
||
|
|
public void InsertIfNewEnough_Duplicate()
|
||
|
|
{
|
||
|
|
SimpleSnapshot a = new SimpleSnapshot(0, 0, 0);
|
||
|
|
SimpleSnapshot b = new SimpleSnapshot(1, 1, 0);
|
||
|
|
SimpleSnapshot c = new SimpleSnapshot(2, 2, 0);
|
||
|
|
|
||
|
|
// add two valid snapshots first.
|
||
|
|
// we can't add 'duplicates' before 3rd and 4th anyway.
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(a, buffer);
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(b, buffer);
|
||
|
|
|
||
|
|
// insert C which is newer than B.
|
||
|
|
// then insert it again because it arrive twice.
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(c, buffer);
|
||
|
|
SnapshotInterpolation.InsertIfNewEnough(c, buffer);
|
||
|
|
|
||
|
|
// count should still be 3.
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(3));
|
||
|
|
}
|
||
|
|
|
||
|
|
[Test]
|
||
|
|
public void CalculateCatchup_Empty()
|
||
|
|
{
|
||
|
|
// make sure nothing happens with buffer size = 0
|
||
|
|
Assert.That(SnapshotInterpolation.CalculateCatchup(buffer, 0, 10), Is.EqualTo(0));
|
||
|
|
}
|
||
|
|
|
||
|
|
[Test]
|
||
|
|
public void CalculateCatchup_None()
|
||
|
|
{
|
||
|
|
// add one
|
||
|
|
buffer.Add(0, default);
|
||
|
|
|
||
|
|
// catch-up starts at threshold = 1. so nothing.
|
||
|
|
Assert.That(SnapshotInterpolation.CalculateCatchup(buffer, 1, 10), Is.EqualTo(0));
|
||
|
|
}
|
||
|
|
|
||
|
|
[Test]
|
||
|
|
public void GetFirstSecondAndDelta()
|
||
|
|
{
|
||
|
|
// add three
|
||
|
|
SimpleSnapshot a = new SimpleSnapshot(0, 1, 0);
|
||
|
|
SimpleSnapshot b = new SimpleSnapshot(2, 3, 0);
|
||
|
|
SimpleSnapshot c = new SimpleSnapshot(10, 20, 0);
|
||
|
|
buffer.Add(a.remoteTimestamp, a);
|
||
|
|
buffer.Add(b.remoteTimestamp, b);
|
||
|
|
buffer.Add(c.remoteTimestamp, c);
|
||
|
|
|
||
|
|
SnapshotInterpolation.GetFirstSecondAndDelta(buffer, out SimpleSnapshot first, out SimpleSnapshot second, out double delta);
|
||
|
|
Assert.That(first, Is.EqualTo(a));
|
||
|
|
Assert.That(second, Is.EqualTo(b));
|
||
|
|
Assert.That(delta, Is.EqualTo(b.remoteTimestamp - a.remoteTimestamp));
|
||
|
|
}
|
||
|
|
|
||
|
|
[Test]
|
||
|
|
public void CalculateCatchup_Multiple()
|
||
|
|
{
|
||
|
|
// add three
|
||
|
|
buffer.Add(0, default);
|
||
|
|
buffer.Add(1, default);
|
||
|
|
buffer.Add(2, default);
|
||
|
|
|
||
|
|
// catch-up starts at threshold = 1. so two are multiplied by 10.
|
||
|
|
Assert.That(SnapshotInterpolation.CalculateCatchup(buffer, 1, 10), Is.EqualTo(20));
|
||
|
|
}
|
||
|
|
|
||
|
|
// first step: with empty buffer and defaults, nothing should happen
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step1_DefaultDoesNothing()
|
||
|
|
{
|
||
|
|
// compute with defaults
|
||
|
|
double localTime = 0;
|
||
|
|
double deltaTime = 0;
|
||
|
|
double interpolationTime = 0;
|
||
|
|
float bufferTime = 0;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should not spit out any snapshot to apply
|
||
|
|
Assert.That(result, Is.False);
|
||
|
|
// no interpolation should have happened yet
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(0));
|
||
|
|
// buffer should still be untouched
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(0));
|
||
|
|
}
|
||
|
|
|
||
|
|
// third step: compute should always wait until the first two snapshots
|
||
|
|
// are older than the time we buffer ('bufferTime')
|
||
|
|
// => test for both snapshots not old enough
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step3_WaitsUntilBufferTime()
|
||
|
|
{
|
||
|
|
// add two snapshots that are barely not old enough
|
||
|
|
// (localTime - bufferTime)
|
||
|
|
// IMPORTANT: use a 'definitely old enough' remoteTime to make sure
|
||
|
|
// that compute() actually checks LOCAL, not REMOTE time!
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(0.1, 0.1, 0);
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(0.9, 1.1, 0);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
buffer.Add(second.remoteTimestamp, second);
|
||
|
|
|
||
|
|
// compute with initialized remoteTime and buffer time of 2 seconds
|
||
|
|
// and a delta time to be sure that we move along it no matter what.
|
||
|
|
double localTime = 3;
|
||
|
|
double deltaTime = 0.5;
|
||
|
|
double interpolationTime = 0;
|
||
|
|
float bufferTime = 2;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should not spit out any snapshot to apply
|
||
|
|
Assert.That(result, Is.False);
|
||
|
|
// no interpolation should happen yet (not old enough)
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(0));
|
||
|
|
// buffer should be untouched
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(2));
|
||
|
|
}
|
||
|
|
|
||
|
|
// third step: compute should always wait until the first two snapshots
|
||
|
|
// are older than the time we buffer ('bufferTime')
|
||
|
|
// => test for only one snapshot which is old enough
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step3_WaitsForSecondSnapshot()
|
||
|
|
{
|
||
|
|
// add a snapshot at t = 0
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(0, 0, 0);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
|
||
|
|
// compute at localTime = 2 with bufferTime = 1
|
||
|
|
// so the threshold is anything < t=1
|
||
|
|
double localTime = 2;
|
||
|
|
double deltaTime = 0;
|
||
|
|
double interpolationTime = 0;
|
||
|
|
float bufferTime = 1;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should not spit out any snapshot to apply
|
||
|
|
Assert.That(result, Is.False);
|
||
|
|
// no interpolation should happen yet (not enough snapshots)
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(0));
|
||
|
|
// buffer should be untouched
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(1));
|
||
|
|
}
|
||
|
|
|
||
|
|
// fourth step: compute should begin if we have two old enough snapshots
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step4_InterpolateWithTwoOldEnoughSnapshots()
|
||
|
|
{
|
||
|
|
// add two old enough snapshots
|
||
|
|
// (localTime - bufferTime)
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(0, 0, 1);
|
||
|
|
// IMPORTANT: second snapshot delta is != 1 so we can be sure that
|
||
|
|
// interpolationTime result is actual time, not 't' ratio.
|
||
|
|
// for a delta of 1, absolute and relative values would
|
||
|
|
// return the same results.
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(2, 2, 2);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
buffer.Add(second.remoteTimestamp, second);
|
||
|
|
|
||
|
|
// compute with initialized remoteTime and buffer time of 2 seconds
|
||
|
|
// and a delta time to be sure that we move along it no matter what.
|
||
|
|
double localTime = 4;
|
||
|
|
double deltaTime = 1.5;
|
||
|
|
double interpolationTime = 0;
|
||
|
|
float bufferTime = 2;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should spit out the interpolated snapshot
|
||
|
|
Assert.That(result, Is.True);
|
||
|
|
// interpolation started just now, from 0.
|
||
|
|
// and deltaTime is 1.5, so we should be at 1.5 now.
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(1.5));
|
||
|
|
// buffer should be untouched, we are still interpolating between the two
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(2));
|
||
|
|
// interpolationTime is at 1.5, so 3/4 between first & second.
|
||
|
|
// computed snapshot should be interpolated at 3/4ths.
|
||
|
|
Assert.That(computed.value, Is.EqualTo(1.75).Within(Mathf.Epsilon));
|
||
|
|
}
|
||
|
|
|
||
|
|
// fourth step: compute should begin if we have two old enough snapshots
|
||
|
|
// => test with 3 snapshots to make sure the third one
|
||
|
|
// isn't touched while t between [0,1]
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step4_InterpolateWithThreeOldEnoughSnapshots()
|
||
|
|
{
|
||
|
|
// add three old enough snapshots.
|
||
|
|
// (localTime - bufferTime)
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(0, 0, 1);
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(1, 1, 2);
|
||
|
|
SimpleSnapshot third = new SimpleSnapshot(2, 2, 2);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
buffer.Add(second.remoteTimestamp, second);
|
||
|
|
buffer.Add(third.remoteTimestamp, third);
|
||
|
|
|
||
|
|
// compute with initialized remoteTime and buffer time of 2 seconds
|
||
|
|
// and a delta time to be sure that we move along it no matter what.
|
||
|
|
double localTime = 4;
|
||
|
|
double deltaTime = 0.5;
|
||
|
|
double interpolationTime = 0;
|
||
|
|
float bufferTime = 2;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should spit out the interpolated snapshot
|
||
|
|
Assert.That(result, Is.True);
|
||
|
|
// interpolation started just now, from 0.
|
||
|
|
// and deltaTime is 0.5, so we should be at 0.5 now.
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(0.5));
|
||
|
|
// buffer should be untouched, we are still interpolating between
|
||
|
|
// the first two. third should still be there.
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(3));
|
||
|
|
// computed snapshot should be interpolated in the middle
|
||
|
|
Assert.That(computed.value, Is.EqualTo(1.5).Within(Mathf.Epsilon));
|
||
|
|
}
|
||
|
|
|
||
|
|
// fourth step: simulate interpolation after a long time of no updates.
|
||
|
|
// for example, a mobile user might put the app in the
|
||
|
|
// background for a minute.
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step4_InterpolateAfterLongPause()
|
||
|
|
{
|
||
|
|
// add two immediate, and one that arrives 100s later
|
||
|
|
// (localTime - bufferTime)
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(0, 0, 0);
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(1, 1, 1);
|
||
|
|
SimpleSnapshot third = new SimpleSnapshot(101, 2, 101);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
buffer.Add(second.remoteTimestamp, second);
|
||
|
|
buffer.Add(third.remoteTimestamp, third);
|
||
|
|
|
||
|
|
// compute where we are half way between first and second,
|
||
|
|
// and now are updated 1 minute later.
|
||
|
|
double localTime = 103; // 1011+bufferTime so third snapshot is old enough
|
||
|
|
double deltaTime = 98.5; // 99s - interpolation time
|
||
|
|
double interpolationTime = 0.5; // half way between first and second
|
||
|
|
float bufferTime = 2;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should spit out the interpolated snapshot
|
||
|
|
Assert.That(result, Is.True);
|
||
|
|
// interpolation started at 0.5, right between first & second.
|
||
|
|
// we received another snapshot at t=101.
|
||
|
|
// delta = 98.5 seconds
|
||
|
|
// => interpolationTime = 99
|
||
|
|
// => overshoots second goal, so we move to third goal and subtract 1
|
||
|
|
// => so we should be at 98 now
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(98));
|
||
|
|
// we moved to the next snapshot. so only 2 should be in buffer now.
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(2));
|
||
|
|
// delta between second and third is 100.
|
||
|
|
// interpolationTime is at 98
|
||
|
|
// interpolationTime is relative to second.time
|
||
|
|
// => InverseLerp(1, 101, 1 + 98) = 0.98
|
||
|
|
// which is at 98% of the value
|
||
|
|
// => Lerp(1, 101, 0.98): 101-1 is 100. 98% are 98. relative to '1'
|
||
|
|
// makes it 99.
|
||
|
|
Assert.That(computed.value, Is.EqualTo(99).Within(Mathf.Epsilon));
|
||
|
|
}
|
||
|
|
|
||
|
|
// fourth step: catchup should be considered if buffer gets too large
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step4_InterpolateWithCatchup()
|
||
|
|
{
|
||
|
|
// add two old enough snapshots
|
||
|
|
// (localTime - bufferTime)
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(0, 0, 1);
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(1, 1, 2);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
buffer.Add(second.remoteTimestamp, second);
|
||
|
|
|
||
|
|
// start applying 25% catchup per excess when > 2.
|
||
|
|
int catchupThreshold = 2;
|
||
|
|
float catchupMultiplier = 0.25f;
|
||
|
|
|
||
|
|
// two excess snapshots to make sure that multiplier is accumulated
|
||
|
|
SimpleSnapshot excess1 = new SimpleSnapshot(2, 2, 3);
|
||
|
|
SimpleSnapshot excess2 = new SimpleSnapshot(3, 3, 4);
|
||
|
|
buffer.Add(excess1.remoteTimestamp, excess1);
|
||
|
|
buffer.Add(excess2.remoteTimestamp, excess2);
|
||
|
|
|
||
|
|
// compute with initialized remoteTime and buffer time of 2 seconds
|
||
|
|
// and a delta time to be sure that we move along it no matter what.
|
||
|
|
double localTime = 3;
|
||
|
|
double deltaTime = 0.5;
|
||
|
|
double interpolationTime = 0;
|
||
|
|
float bufferTime = 2;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should spit out the interpolated snapshot
|
||
|
|
Assert.That(result, Is.True);
|
||
|
|
// interpolation started just now, from 0.
|
||
|
|
// and deltaTime is 0.5 + 50% catchup, so we should be at 0.75 now
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(0.75));
|
||
|
|
// buffer should be untouched, we are still interpolating between
|
||
|
|
// the first two.
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(4));
|
||
|
|
// computed snapshot should be interpolated in 3/4 because
|
||
|
|
// interpolationTime is at 3/4
|
||
|
|
Assert.That(computed.value, Is.EqualTo(1.75).Within(Mathf.Epsilon));
|
||
|
|
}
|
||
|
|
|
||
|
|
// fifth step: interpolation time overshoots the end while waiting for
|
||
|
|
// more snapshots.
|
||
|
|
//
|
||
|
|
// IMPORTANT: we should NOT extrapolate & predict while waiting for more
|
||
|
|
// snapshots as this would introduce a whole range of issues:
|
||
|
|
// * player might be extrapolated WAY out if we wait for long
|
||
|
|
// * player might be extrapolated behind walls
|
||
|
|
// * once we receive a new snapshot, we would interpolate
|
||
|
|
// not from the last valid position, but from the
|
||
|
|
// extrapolated position. this could be ANYWHERE. the
|
||
|
|
// player might get stuck in walls, etc.
|
||
|
|
// => we are NOT doing client side prediction & rollback here
|
||
|
|
// => we are simply interpolating with known, valid positions
|
||
|
|
//
|
||
|
|
// NOTE: to reproduce the issue in a real example:
|
||
|
|
// * open mirror benchmark example
|
||
|
|
// * editor=host 1000+ monsters & deep profiling for LOW FPS
|
||
|
|
// * build=client
|
||
|
|
// * move around client
|
||
|
|
// * see it all over the place in editor because it extrapolates,
|
||
|
|
// ends up at the wrong start positions and gets worse from
|
||
|
|
// there.
|
||
|
|
//
|
||
|
|
// video: https://gyazo.com/8de68f0a821449d7b9a8424e2c9e3ff8
|
||
|
|
// (or see Mirror/Docs/Screenshots/NT Snap. Interp./extrapolation issues)
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step5_OvershootWithoutEnoughSnapshots()
|
||
|
|
{
|
||
|
|
// add two old enough snapshots
|
||
|
|
// (localTime - bufferTime)
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(0, 0, 1);
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(1, 1, 2);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
buffer.Add(second.remoteTimestamp, second);
|
||
|
|
|
||
|
|
// compute with initialized remoteTime and buffer time of 2 seconds
|
||
|
|
// and a delta time to be sure that we move along it no matter what.
|
||
|
|
// -> interpolation time is already at '1' at the end.
|
||
|
|
// -> compute will add 0.5 deltaTime
|
||
|
|
// -> so we should NOT overshoot aka extrapolate beyond second snap.
|
||
|
|
double localTime = 3;
|
||
|
|
double deltaTime = 0.5;
|
||
|
|
double interpolationTime = 1;
|
||
|
|
float bufferTime = 2;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should spit out the interpolated snapshot
|
||
|
|
Assert.That(result, Is.True);
|
||
|
|
// interpolation started at the end = 1
|
||
|
|
// and deltaTime is 0.5, so it's at 1.5 internally.
|
||
|
|
//
|
||
|
|
// BUT there's NO reason to overshoot interpolationTime if there's
|
||
|
|
// no other snapshots to move to.
|
||
|
|
// interpolationTime overshoot is only for smooth transitions WHILE
|
||
|
|
// moving.
|
||
|
|
// for example, if we keep overshooting to 100, then we would
|
||
|
|
// instantly skip the next 20 snapshots.
|
||
|
|
// => so it should be capped at second.remoteTime
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(1));
|
||
|
|
// buffer should be untouched, we are still interpolating between the two
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(2));
|
||
|
|
// computed snapshot should NOT extrapolate beyond second snap.
|
||
|
|
Assert.That(computed.value, Is.EqualTo(2).Within(Mathf.Epsilon));
|
||
|
|
}
|
||
|
|
|
||
|
|
// fifth step: interpolation time overshoots the end while having more
|
||
|
|
// snapshots available.
|
||
|
|
// BUT: the next snapshot isn't old enough yet.
|
||
|
|
// we shouldn't move there until old enough.
|
||
|
|
// for the same reason we don't move to first, second
|
||
|
|
// until they are old enough.
|
||
|
|
// => always need to be 'bufferTime' old.
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step5_OvershootWithEnoughSnapshots_NextIsntOldEnough()
|
||
|
|
{
|
||
|
|
// add two old enough snapshots
|
||
|
|
// (localTime - bufferTime)
|
||
|
|
//
|
||
|
|
// IMPORTANT: second.time needs to be != second.time-first.time
|
||
|
|
// to guarantee that we cap interpolationTime (which is
|
||
|
|
// RELATIVE from 0..delta) at delta, not at second.time.
|
||
|
|
// this was a bug before.
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(1, 1, 1);
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(2, 2, 2);
|
||
|
|
// IMPORTANT: third snapshot needs to be:
|
||
|
|
// - a different time delta
|
||
|
|
// to test if overflow is correct if deltas are different.
|
||
|
|
// it's not obvious if we ever use t ratio between [0,1] where an
|
||
|
|
// overflow of 0.1 between A,B could speed up B,C interpolation if
|
||
|
|
// that's not the same delta, since t is a ratio.
|
||
|
|
// - a different value delta to check if it really _interpolates_,
|
||
|
|
// not just extrapolates further after A,B
|
||
|
|
SimpleSnapshot third = new SimpleSnapshot(4, 4, 4);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
buffer.Add(second.remoteTimestamp, second);
|
||
|
|
buffer.Add(third.remoteTimestamp, third);
|
||
|
|
|
||
|
|
// compute with initialized remoteTime and buffer time of 2 seconds
|
||
|
|
// and a delta time to be sure that we move along it no matter what.
|
||
|
|
// -> interpolation time is already at '1' at the end.
|
||
|
|
// -> compute will add 0.5 deltaTime
|
||
|
|
// -> so we overshoot beyond the second one and move to the next
|
||
|
|
//
|
||
|
|
// localTime is at 4
|
||
|
|
// third snapshot localTime is at 4.
|
||
|
|
// bufferTime is 2, so it is NOT old enough and we should wait!
|
||
|
|
double localTime = 4;
|
||
|
|
double deltaTime = 0.5;
|
||
|
|
double interpolationTime = 1;
|
||
|
|
float bufferTime = 2;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should still spit out a result between first & second.
|
||
|
|
Assert.That(result, Is.True);
|
||
|
|
// interpolation started at the end = 1
|
||
|
|
// and deltaTime is 0.5, so we were at 1.5 internally.
|
||
|
|
//
|
||
|
|
// BUT there's NO reason to overshoot interpolationTime while we
|
||
|
|
// wait for the next snapshot which isn't old enough.
|
||
|
|
// we stopped movement anyway.
|
||
|
|
// interpolationTime overshoot is only for smooth transitions WHILE
|
||
|
|
// moving.
|
||
|
|
// for example, if we overshoot to 100 while waiting, then we would
|
||
|
|
// instantly skip the next 20 snapshots.
|
||
|
|
// => so it should be capped at max
|
||
|
|
// => which is always 0..delta, NOT first.time .. second.time!!
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(1));
|
||
|
|
// buffer should be untouched. shouldn't have moved to third yet.
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(3));
|
||
|
|
// computed snapshot should be all the way at second snapshot.
|
||
|
|
Assert.That(computed.value, Is.EqualTo(2).Within(Mathf.Epsilon));
|
||
|
|
}
|
||
|
|
|
||
|
|
// fifth step: interpolation time overshoots the end while having more
|
||
|
|
// snapshots available.
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step5_OvershootWithEnoughSnapshots_MovesToNextSnapshotIfOldEnough()
|
||
|
|
{
|
||
|
|
// add two old enough snapshots
|
||
|
|
// (localTime - bufferTime)
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(0, 0, 1);
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(1, 1, 2);
|
||
|
|
// IMPORTANT: third snapshot needs to be:
|
||
|
|
// - a different time delta
|
||
|
|
// to test if overflow is correct if deltas are different.
|
||
|
|
// it's not obvious if we ever use t ratio between [0,1] where an
|
||
|
|
// overflow of 0.1 between A,B could speed up B,C interpolation if
|
||
|
|
// that's not the same delta, since t is a ratio.
|
||
|
|
// - a different value delta to check if it really _interpolates_,
|
||
|
|
// not just extrapolates further after A,B
|
||
|
|
SimpleSnapshot third = new SimpleSnapshot(3, 3, 4);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
buffer.Add(second.remoteTimestamp, second);
|
||
|
|
buffer.Add(third.remoteTimestamp, third);
|
||
|
|
|
||
|
|
// compute with initialized remoteTime and buffer time of 2 seconds
|
||
|
|
// and a delta time to be sure that we move along it no matter what.
|
||
|
|
// -> interpolation time is already at '1' at the end.
|
||
|
|
// -> compute will add 0.5 deltaTime
|
||
|
|
// -> so we overshoot beyond the second one and move to the next
|
||
|
|
//
|
||
|
|
// localTime is 5. third snapshot localTime is at 3.
|
||
|
|
// bufferTime is 2.
|
||
|
|
// so third is exactly old enough and we should move there.
|
||
|
|
double localTime = 5;
|
||
|
|
double deltaTime = 0.5;
|
||
|
|
double interpolationTime = 1;
|
||
|
|
float bufferTime = 2;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should spit out the interpolated snapshot
|
||
|
|
Assert.That(result, Is.True);
|
||
|
|
// interpolation started at the end = 1
|
||
|
|
// and deltaTime is 0.5, so we were at 1.5 internally.
|
||
|
|
// we have more snapshots, so we jump to the next and subtract '1'
|
||
|
|
// 1 + 0.5 = 1.5 => -1 => 0.5
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(0.5));
|
||
|
|
// buffer's first entry should have been removed
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(2));
|
||
|
|
// computed snapshot should be 1/4 way between second and third
|
||
|
|
// because delta is 2 and interpolationTime is at 0.5 which is 1/4
|
||
|
|
Assert.That(computed.value, Is.EqualTo(2.5).Within(Mathf.Epsilon));
|
||
|
|
}
|
||
|
|
|
||
|
|
// fifth step: interpolation time overshoots 2x the end while having
|
||
|
|
// >= 2 more snapshots available. it should correctly jump
|
||
|
|
// ahead the first pending one to the second one.
|
||
|
|
[Test]
|
||
|
|
public void Compute_Step5_OvershootWithEnoughSnapshots_2x_MovesToSecondNextSnapshot()
|
||
|
|
{
|
||
|
|
// add two old enough snapshots
|
||
|
|
// (localTime - bufferTime)
|
||
|
|
SimpleSnapshot first = new SimpleSnapshot(0, 0, 1);
|
||
|
|
SimpleSnapshot second = new SimpleSnapshot(1, 1, 2);
|
||
|
|
// IMPORTANT: third snapshot needs to be:
|
||
|
|
// - a different time delta
|
||
|
|
// to test if overflow is correct if deltas are different.
|
||
|
|
// it's not obvious if we ever use t ratio between [0,1] where an
|
||
|
|
// overflow of 0.1 between A,B could speed up B,C interpolation if
|
||
|
|
// that's not the same delta, since t is a ratio.
|
||
|
|
// - a different value delta to check if it really _interpolates_,
|
||
|
|
// not just extrapolates further after A,B
|
||
|
|
SimpleSnapshot third = new SimpleSnapshot(3, 3, 4);
|
||
|
|
SimpleSnapshot fourth = new SimpleSnapshot(5, 5, 6);
|
||
|
|
buffer.Add(first.remoteTimestamp, first);
|
||
|
|
buffer.Add(second.remoteTimestamp, second);
|
||
|
|
buffer.Add(third.remoteTimestamp, third);
|
||
|
|
buffer.Add(fourth.remoteTimestamp, fourth);
|
||
|
|
|
||
|
|
// compute with initialized remoteTime and buffer time of 2 seconds
|
||
|
|
// and a delta time to be sure that we move along it no matter what.
|
||
|
|
// -> interpolation time is already at '1' at the end.
|
||
|
|
// -> compute will add 1.5 deltaTime
|
||
|
|
// -> so we should overshoot beyond second and third even
|
||
|
|
//
|
||
|
|
// localTime is 7. fourth snapshot localTime is at 5.
|
||
|
|
// bufferTime is 2.
|
||
|
|
// so fourth is exactly old enough and we should move there.
|
||
|
|
double localTime = 7;
|
||
|
|
double deltaTime = 2.5;
|
||
|
|
double interpolationTime = 1;
|
||
|
|
float bufferTime = 2;
|
||
|
|
int catchupThreshold = Int32.MaxValue;
|
||
|
|
float catchupMultiplier = 0;
|
||
|
|
bool result = SnapshotInterpolation.Compute(localTime, deltaTime, ref interpolationTime, bufferTime, buffer, catchupThreshold, catchupMultiplier, SimpleSnapshot.Interpolate, out SimpleSnapshot computed);
|
||
|
|
|
||
|
|
// should spit out the interpolated snapshot
|
||
|
|
Assert.That(result, Is.True);
|
||
|
|
// interpolation started at the end = 1
|
||
|
|
// and deltaTime is 2.5, so we were at 4.5 internally.
|
||
|
|
// we have more snapshots, so we:
|
||
|
|
// * jump to third, subtract delta of 1-0 = 1 => 2.5
|
||
|
|
// * jump to fourth, subtract delta of 3-1 = 2 => 0.5
|
||
|
|
// * end up at 0.5 again, between third and fourth
|
||
|
|
Assert.That(interpolationTime, Is.EqualTo(0.5));
|
||
|
|
// buffer's first entry should have been removed
|
||
|
|
Assert.That(buffer.Count, Is.EqualTo(2));
|
||
|
|
// computed snapshot should be 1/4 way between second and third
|
||
|
|
// because delta is 2 and interpolationTime is at 0.5 which is 1/4
|
||
|
|
Assert.That(computed.value, Is.EqualTo(4.5).Within(Mathf.Epsilon));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|