update

Minor adjustment to smooth dampening.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs

@@ -279,6 +279,7 @@ private void TryConsumeFromBuffer(double renderTime, float minDeltaTime, float m
                                 // TODO: We might consider creating yet another queue to add these items to and assure that the time is accelerated
                                 // for each item as opposed to losing the resolution of the values.
                                 InterpolateState.TimeToTargetValue = Mathf.Clamp((float)(target.TimeSent - startTime), minDeltaTime, maxDeltaTime);
+
                                 InterpolateState.Target = target;
                             }
                             InterpolateState.ResetDelta();
@@ -321,11 +322,11 @@ public T Update(float deltaTime, double tickLatencyAsTime, float minDeltaTime, f
                 // Smooth dampen our current time
                 var current = SmoothDamp(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, ref m_RateOfChange, InterpolateState.TimeToTargetValue, InterpolateState.DeltaTime);
                 // Smooth dampen a predicted time based on our average delta time 
-                var predict = SmoothDamp(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, ref m_PredictedRateOfChange, InterpolateState.TimeToTargetValue, InterpolateState.DeltaTime + InterpolateState.AverageDeltaTime);
-                // Split the difference between the two.
+                var predict = SmoothDamp(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, ref m_PredictedRateOfChange, InterpolateState.TimeToTargetValue, InterpolateState.DeltaTime + (InterpolateState.AverageDeltaTime * 2));
+                // Lerp between the current and predicted.
                 // Note: Since smooth dampening cannot over shoot, both current and predict will eventually become the same or will be very close to the same.
                 // Upon stopping motion, the final resing value should be a very close aproximation of the authority side.
-                InterpolateState.CurrentValue = Interpolate(current, predict, 0.5f);
+                InterpolateState.CurrentValue = Interpolate(current, predict, deltaTime);
             }
             m_NbItemsReceivedThisFrame = 0;
             return InterpolateState.CurrentValue;

com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs

@@ -3786,8 +3786,10 @@ private void UpdateInterpolation()
             }
 
             var tickLatencyAsTime = m_CachedNetworkManager.LocalTime.TimeTicksAgo(tickLatency).Time;
+            // Smooth dampening specific:
+            // We clamp between tick rate and bit beyond the tick rate but not 2x tick rate (we predict 2x out)
             var minDeltaTime = m_CachedNetworkManager.LocalTime.FixedDeltaTime;
-            var maxDeltaTime = (tickLatency * m_CachedNetworkManager.ServerTime.FixedDeltaTime);
+            var maxDeltaTime = (1.666667f * m_CachedNetworkManager.ServerTime.FixedDeltaTime);
 
             // Now only update the interpolators for the portions of the transform being synchronized
             if (SynchronizePosition)