update

Made some more adjustments as well as added a predicted smooth dampened value to help with smoothing and to get closer to the target value on the non-authority side.
Updated the Quaternion's Approximation to use the dot product instead.

Author: NoelStephensUnity

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

@@ -71,6 +71,7 @@ public void AddDeltaTime(float deltaTime)
                 else
                 {
                     m_AverageDeltaTime += deltaTime;
+                    m_AverageDeltaTime *= 0.5f;
                 }
                 DeltaTime = Math.Min(DeltaTime + m_AverageDeltaTime, TimeToTargetValue);
                 LerpT = TimeToTargetValue == 0.0f ? 1.0f : DeltaTime / TimeToTargetValue;
@@ -97,7 +98,7 @@ public void Reset(T currentValue)
                 CurrentValue = currentValue;
                 PreviousValue = currentValue;
                 // When reset, we consider ourselves to have already arrived at the target (even if no target is set)
-                LerpT = 1.0f;
+                LerpT = 0.0f;
                 EndTime = 0.0;
                 StartTime = 0.0;
                 ResetDelta();
@@ -169,6 +170,11 @@ public void Reset(T currentValue)
         /// </summary>
         private T m_RateOfChange;
 
+        /// <summary>
+        /// Represents the predicted rate of change for the value being interpolated when smooth dampening is enabled.
+        /// </summary>
+        private T m_PredictedRateOfChange;
+
         private bool m_IsAngularValue;
 
         /// <summary>
@@ -225,8 +231,8 @@ private void InternalReset(T targetValue, double serverTime, bool isAngularValue
         /// <param name="maxDeltaTime">maximum time delta which defines the maximum time duration when consuming more than one item from the buffer</param>
         private void TryConsumeFromBuffer(double renderTime, float minDeltaTime, float maxDeltaTime)
         {
-            if (!InterpolateState.Target.HasValue || (InterpolateState.Target.Value.TimeSent <= renderTime &&
-                (InterpolateState.TargetTimeAproximatelyReached() || IsAproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item))))
+            if (!InterpolateState.Target.HasValue || (InterpolateState.Target.Value.TimeSent <= renderTime
+                 && (InterpolateState.TargetTimeAproximatelyReached() || IsAproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item))))
             {
                 BufferedItem? previousItem = null;
                 var startTime = 0.0;
@@ -309,7 +315,15 @@ public T Update(float deltaTime, double tickLatencyAsTime, float minDeltaTime, f
             if (InterpolateState.Target.HasValue)
             {
                 InterpolateState.AddDeltaTime(deltaTime);
-                InterpolateState.CurrentValue = SmoothDamp(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, ref m_RateOfChange, InterpolateState.TimeToTargetValue, deltaTime);
+
+                // 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.
+                // 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);
             }
             m_NbItemsReceivedThisFrame = 0;
             return InterpolateState.CurrentValue;
@@ -381,15 +395,6 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)
                 }
             }
         }
-        #endregion
-
-        /// <summary>
-        /// Used for internal testing
-        /// </summary>
-        internal T UpdateInternal(float deltaTime, NetworkTime serverTime)
-        {
-            return Update(deltaTime, serverTime.TimeTicksAgo(1).Time, serverTime.Time);
-        }
 
         /// <summary>
         /// Call to update the state of the interpolators using Lerp.
@@ -432,6 +437,15 @@ public T Update(float deltaTime, double renderTime, double serverTime)
             m_NbItemsReceivedThisFrame = 0;
             return InterpolateState.CurrentValue;
         }
+        #endregion
+
+        /// <summary>
+        /// Used for internal testing
+        /// </summary>
+        internal T UpdateInternal(float deltaTime, NetworkTime serverTime)
+        {
+            return Update(deltaTime, serverTime.TimeTicksAgo(1).Time, serverTime.Time);
+        }
 
         /// <summary>
         /// Add measurements to be used during interpolation. These will be buffered before being made available to be displayed as "latest value".

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

@@ -63,10 +63,7 @@ protected internal override Quaternion SmoothDamp(Quaternion current, Quaternion
         /// <inheritdoc />
         protected internal override bool IsAproximately(Quaternion first, Quaternion second, float precision)
         {
-            return Mathf.Abs(first.x - second.x) <= precision &&
-                Mathf.Abs(first.y - second.y) <= precision &&
-                Mathf.Abs(first.z - second.z) <= precision &&
-                Mathf.Abs(first.w - second.w) <= precision;
+            return (1.0f - Quaternion.Dot(first, second)) <= precision;
         }
 
         /// <inheritdoc />

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

@@ -1820,11 +1820,13 @@ private bool CheckForStateChange(ref NetworkTransformState networkState, ref Tra
             var positionThreshold = Vector3.one * PositionThreshold;
             var rotationThreshold = Vector3.one * RotAngleThreshold;
 
-            if (m_UseRigidbodyForMotion)
-            {
-                positionThreshold = m_NetworkRigidbodyInternal.GetAdjustedPositionThreshold();
-                rotationThreshold = m_NetworkRigidbodyInternal.GetAdjustedRotationThreshold();
-            }
+            // NSS: Disabling this for the time being
+            // TODO: Determine if we actually need this and if not remove this from NetworkRigidBodyBase
+            //if (m_UseRigidbodyForMotion)
+            //{
+            //    positionThreshold = m_NetworkRigidbodyInternal.GetAdjustedPositionThreshold();
+            //    rotationThreshold = m_NetworkRigidbodyInternal.GetAdjustedRotationThreshold();
+            //}
 #else
             var position = InLocalSpace ? transformToUse.localPosition : transformToUse.position;
             var rotation = InLocalSpace ? transformToUse.localRotation : transformToUse.rotation;

com.unity.netcode.gameobjects/Runtime/Timing/NetworkTimeSystem.cs

@@ -225,7 +225,7 @@ public bool Advance(double deltaTimeSec)
             if (LastSyncedRttSec > 0.0f)
             {
                 m_TickLatencyAverage = Mathf.Lerp(m_TickLatencyAverage, (float)((LastSyncedRttSec + deltaTimeSec) / m_TickFrequency), (float)deltaTimeSec);
-                TickLatency = (int)Mathf.Max(1.0f, Mathf.Round(m_TickLatencyAverage));
+                TickLatency = (int)Mathf.Max(2.0f, Mathf.Round(m_TickLatencyAverage));
             }
 
             if (Math.Abs(m_DesiredLocalTimeOffset - m_CurrentLocalTimeOffset) > HardResetThresholdSec || Math.Abs(m_DesiredServerTimeOffset - m_CurrentServerTimeOffset) > HardResetThresholdSec)