PredictedObjectOwnerSmoother Improvement

[Xelopie]

The original implementation is good enough for most cases. Still, I have seen many FN users claiming that jittering happens when being as the owner of the object (no jittering for non-owned object). Most of us also use a smooth follow camera for the character, which could just make the problem much obvious. I have just come across this problem as well and spent a couple of days on it. And finally got some progress!

By recording the game and playing it back frame by frame, you can see that the jitter is not "going back and forth" (with fixed camera). It is moving forward with inconsistent speed only which causes an illusion of jittering. If using smooth follow camera with character moving at constant speed, there will be some frames where the object suddenly stops but the camera keep moving forward (kinda looks like jittering).

Straight to the code: (see the CHECK THIS tag)
First, the SetGraphicalMoveRates() method, which is called before ticking.

private void SetGraphicalMoveRates()
{
    float delta = ((float)_networkBehaviour.TimeManager.TickDelta * _interpolation); // <------ if _interpolation == 1, then delta == TickDelta exactly

    float distance;
    distance = Vector3.Distance(_graphicalObject.position, GetGraphicalGoalPosition());
    //If qualifies for teleporting.
    if (_teleportThreshold != -1f && distance >= _teleportThreshold)
    {
        _positionMoveRate = -1f;
        _rotationMoveRate = -1f;
    }
    //Smoothing.
    else
    {
        _positionMoveRate = (distance / delta); // <----- CHECK THIS!!!!!!
        distance = Quaternion.Angle(_graphicalObject.rotation, GetGraphicalGoalRotation());
        if (distance > 0f)
            _rotationMoveRate = (distance / delta);
    }
}

Second method, MoveToTarget(), called on TimeManager.OnUpdate

private void MoveToTarget()
{
    //Not set, meaning movement doesnt need to happen or completed.
    if (_positionMoveRate == -2f && _rotationMoveRate == -2f)
        return;

    Vector3 posGoal = GetGraphicalGoalPosition();
    Quaternion rotGoal = GetGraphicalGoalRotation();

    /* Only try to update properties if they have a valid move rate.
     * Properties may have 0f move rate if they did not change. */
    Transform t = _graphicalObject;
    float delta = Time.deltaTime; // <---- CHECK THIS!!!!

    //Position.
    if (SmoothPosition())
    {
        if (_positionMoveRate == -1f)
            ResetGraphicalToInstantiatedProperties(true, false);
        else if (_positionMoveRate > 0f)
            t.position = Vector3.MoveTowards(t.position, posGoal, _positionMoveRate * delta); // <---- CHECK THIS!!!!
    }

    //Rotation.
    if (SmoothRotation())
    {
        if (_rotationMoveRate == -1f)
            ResetGraphicalToInstantiatedProperties(false, true);
        else if (_rotationMoveRate > 0f)
            t.rotation = Quaternion.RotateTowards(t.rotation, rotGoal, _rotationMoveRate * delta);
    }

    if (GraphicalObjectMatches(posGoal, rotGoal))
    {
        _positionMoveRate = -2f;
        _rotationMoveRate = -2f;
    } 
}

Some simple maths here to illustrate the problem:
Put them into an actual use case.
Let say if the Time.time is exactly 1 now, and TimeManager runs from the beginning.
Time.time = 1 (ticked in this frame)

If you spend >0.02 sec to go to next frame, let say 0.03 sec (Time.deltaTime = 0.03)
At Time.time = 1.03 sec (ticked in this frame because >0.02, Time.deltaTime = 0.03)

When distance to interpolate = 10 units (object position at Time=1: 0; object position at Time=1.03: 10)
TickDelta = 0.02 sec (50 ticks/sec)
position move rate = 10/0.02 = 500 units/sec

If you follow the AfterTick update order in TimeManager, OnUpdate will be called after PostTick.
At this point, in MoveToTarget() method, _positionMoveRate * delta = 500 * 0.03 = 15 units ???????????????????
15 is even larger than 10 which is the distance you should interpolate. Of course, by using Vector3.MoveTowards, the final value will be clamped by target. But this update will still shoot your character straight to the real object position, which means no interpolation at all.

The correct interpolation distance should be:
_positionMoveRate * (excess deltaTime after minus TickDelta)
= 500 * (0.03 - 0.02)
= 5 units (the graphic aspect had been reset back to default position already in PreTick)

---

A quick fix from my version of NetworkRigidbody

/// <summary>
/// Moves transform to target values.
/// </summary>
private void MoveToTarget()
{
    if (GraphicalObjectMatches(_instantiatedLocalPosition, _instantiatedLocalRotation))
    {
        return;
    }

    /* Only try to update properties if they have a valid move rate.
     * Properties may have 0f move rate if they did not change. */
    Transform t = _graphicalObject;
    if (_canTeleport)
    {
        t.localPosition = _instantiatedLocalPosition;
        t.localRotation = _instantiatedLocalRotation;
    }
    else
    {
        float ratio = (float)TimeManager.GetTickPercent() / 100f;
        t.position = Vector3.Lerp(_previousPosition, _targetPosition, ratio);
        t.rotation = Quaternion.Lerp(_previousRotation, _targetRotation, ratio);
    }
}

/// <summary>
/// Sets Position and Rotation move rates to reach Target datas.
/// </summary>
private void SetMoveTargetProperties()
{
    var parent = _graphicalObject.parent;
    _targetPosition = parent == null ? _instantiatedLocalPosition : parent.TransformPoint(_instantiatedLocalPosition);
    _targetRotation = parent == null ? _instantiatedLocalRotation : parent.rotation * _instantiatedLocalRotation;

    float distance = Vector3.Distance(_targetPosition, _graphicalObject.position);
    //If qualifies for teleporting.
    if (_enableTeleport && distance >= _teleportThreshold)
    {
        _canTeleport = true;
    }
    else
    {
        _canTeleport = false;
    }
}

This has greatly reduced the jittering caused by inconsistent interpolation even when moving at constant speed while I have only tested in the "TimeManager update order: After Tick" setup (my game follows this setup).

Hope this can help.

[Xelopie]

reference source: https://kinematicsoup.com/news/2016/8/9/rrypp5tkubynjwxhxjzd42s3o034o8

[FirstGearGames]

Added/not relevant anymore.