fix

Removing unclamped slerp and lerp due to a few timing related issues.  These issues should be solved before re-enabling any form of unclamped lerping/slerping with BufferedLinearInterpolator.

Added additional comments in some areas to be investigated for a potential fix.

Author: NoelStephensUnity

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

@@ -248,6 +248,8 @@ public void AddMeasurement(T newMeasurement, double sentTime)
                 return;
             }
 
+            // Part the of reason for disabling extrapolation is how we add and use measurements over time.
+            // TODO: Add detailed description of this area in Jira ticket
             if (sentTime > m_EndTimeConsumed || m_LifetimeConsumedCount == 0) // treat only if value is newer than the one being interpolated to right now
             {
                 m_LastBufferedItemReceived = new BufferedItem(newMeasurement, sentTime);
@@ -292,7 +294,9 @@ public class BufferedLinearInterpolatorFloat : BufferedLinearInterpolator<float>
         /// <inheritdoc />
         protected override float InterpolateUnclamped(float start, float end, float time)
         {
-            return Mathf.LerpUnclamped(start, end, time);
+            // Disabling Extrapolation:
+            // TODO: Add Jira Ticket
+            return Mathf.Lerp(start, end, time);
         }
 
         /// <inheritdoc />
@@ -311,13 +315,17 @@ public class BufferedLinearInterpolatorQuaternion : BufferedLinearInterpolator<Q
         /// <inheritdoc />
         protected override Quaternion InterpolateUnclamped(Quaternion start, Quaternion end, float time)
         {
-            return Quaternion.SlerpUnclamped(start, end, time);
+            // Disabling Extrapolation:
+            // TODO: Add Jira Ticket
+            return Quaternion.Slerp(start, end, time);
         }
 
         /// <inheritdoc />
         protected override Quaternion Interpolate(Quaternion start, Quaternion end, float time)
         {
-            return Quaternion.SlerpUnclamped(start, end, time);
+            // Disabling Extrapolation:
+            // TODO: Add Jira Ticket
+            return Quaternion.Slerp(start, end, time);
         }
     }
 }

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

@@ -453,9 +453,6 @@ internal NetworkVariable<NetworkTransformState> ReplicatedNetworkState
         // Used by integration test
         private NetworkTransformState m_LastSentState;
 
-        // Used by the non-authoritative side to handle ending extrapolation
-        private NetworkTransformState m_LastReceivedState;
-
         internal NetworkTransformState GetLastSentState()
         {
             return m_LastSentState;
@@ -556,6 +553,8 @@ private void ResetInterpolatedStateToCurrentAuthoritativeState()
 
             m_RotationInterpolator.ResetTo(transform.rotation, serverTime);
 
+            // TODO: (Create Jira Ticket) Synchronize local scale during NetworkObject synchronization
+            // (We will probably want to byte pack TransformData to offset the 3 float addition)
             m_ScaleXInterpolator.ResetTo(transform.localScale.x, serverTime);
             m_ScaleYInterpolator.ResetTo(transform.localScale.y, serverTime);
             m_ScaleZInterpolator.ResetTo(transform.localScale.z, serverTime);
@@ -938,26 +937,6 @@ private void AddInterpolatedState(NetworkTransformState newState)
             }
         }
 
-        /// <summary>
-        /// Stops extrapolating the <see cref="m_LastReceivedState"/>.
-        /// </summary>
-        /// <remarks>
-        /// <see cref="OnNetworkStateChanged"/>
-        /// </remarks>
-        private void TryToStopExtrapolatingLastState()
-        {
-            if (!m_LastReceivedState.IsDirty || m_LastReceivedState.EndExtrapolationTick >= NetworkManager.LocalTime.Tick)
-            {
-                return;
-            }
-            // Offset by 1 tick duration
-            m_LastReceivedState.SentTime += m_TickFrequency;
-            AddInterpolatedState(m_LastReceivedState);
-
-            // Now reset our last received state so we won't apply this state again
-            m_LastReceivedState.ClearBitSetForNextTick();
-        }
-
         /// <summary>
         /// Only non-authoritative instances should invoke this method
         /// </summary>
@@ -976,21 +955,8 @@ private void OnNetworkStateChanged(NetworkTransformState oldState, NetworkTransf
 
             if (Interpolate)
             {
-                // This is "just in case" we receive a new state before the end
-                // of any currently applied and potentially extrapolating state.
-                // Attempts to stop extrapolating any previously applied state.
-                TryToStopExtrapolatingLastState();
-
                 // Add measurements for the new state's deltas
                 AddInterpolatedState(newState);
-
-                // Set the last received state to the new state (will be used to stop extrapolating the new state on the next local tick)
-                m_LastReceivedState = newState;
-
-                // Set the current local tick and wait until the next tick before we end
-                // this state's potential of extrapolating past the target value beyond
-                // the state's relative tick duration
-                m_LastReceivedState.EndExtrapolationTick = NetworkManager.LocalTime.Tick;
             }
         }
 
@@ -1115,6 +1081,11 @@ private void Initialize()
                 // In case we are late joining
                 ResetInterpolatedStateToCurrentAuthoritativeState();
             }
+
+            if (!IsServer)
+            {
+                Interpolate = false;
+            }
         }
 
         /// <summary>
@@ -1261,6 +1232,10 @@ protected virtual void Update()
             {
                 return;
             }
+            if (!IsServer)
+            {
+                Interpolate = false;
+            }
 
             // If we are authority, update the authoritative state
             if (CanCommitToTransform)
@@ -1285,9 +1260,6 @@ protected virtual void Update()
 
                 // Apply the current authoritative state
                 ApplyAuthoritativeState();
-
-                // Attempts to stop extrapolating any previously applied state.
-                TryToStopExtrapolatingLastState();
             }
         }