fix: LegacyLerp was using ticklatency as opposed to legacy ticksAgo (#3381)

NoelStephensUnity · web-flow · commit bb0566c77d20 · 2025-04-04T09:39:50.000+02:00
This update resolves the issue where the legacy lerp result was not
yielding the same result as the original lerp. This update also resolves
a secondary issue discovered by the services group where the final
interpolation (i.e. last measurement in the queue) was not using a high
enough precision value when determining if it reached its final
destination point. This update also includes some inlining additions
along with a spelling mistake with the IsApproximately method. It also
updates the XML API regarding Legacy lerp to let users know that it does
not use the tick latency value when calculating the ticksAgo value.


## Changelog
NA

## Testing and Documentation

- No tests have been added.
- Includes edits to existing API XML documentation.

&lt;!-- Uncomment and mark items off with a * if this PR deprecates any
API:
### Deprecated API
- [ ] An `[Obsolete]` attribute was added along with a `(RemovedAfter
yyyy-mm-dd)` entry.
- [ ] An [api updater] was added.
- [ ] Deprecation of the API is explained in the CHANGELOG.
- [ ] The users can understand why this API was removed and what they
should use instead.
--&gt;
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs b/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using UnityEngine;
 
 namespace Unity.Netcode
@@ -14,9 +15,16 @@ public abstract class BufferedLinearInterpolator<T> where T : struct
         // Constant absolute value for max buffer count instead of dynamic time based value. This is in case we have very low tick rates, so
         // that we don't have a very small buffer because of this.
         private const int k_BufferCountLimit = 100;
-        private const float k_AproximatePrecision = 0.0001f;
+        private const float k_ApproximateLowPrecision = 0.000001f;
+        private const float k_ApproximateHighPrecision = 1E-10f;
         private const double k_SmallValue = 9.999999439624929E-11; // copied from Vector3's equal operator
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private float GetPrecision()
+        {
+            return m_BufferQueue.Count == 0 ? k_ApproximateHighPrecision : k_ApproximateLowPrecision;
+        }
+
         #region Legacy notes
         // Buffer consumption scenarios
         // Perfect case consumption
@@ -132,20 +140,23 @@ internal struct CurrentState
             public float CurrentDeltaTime => m_CurrentDeltaTime;
             public double FinalTimeToTarget => Math.Max(0.0, TimeToTargetValue - DeltaTime);
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void AddDeltaTime(float deltaTime)
             {
                 m_CurrentDeltaTime = deltaTime;
                 DeltaTime = Math.Min(DeltaTime + deltaTime, TimeToTargetValue);
                 LerpT = (float)(TimeToTargetValue == 0.0 ? 1.0 : DeltaTime / TimeToTargetValue);
             }
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void SetTimeToTarget(double timeToTarget)
             {
                 LerpT = 0.0f;
                 DeltaTime = 0.0f;
                 TimeToTargetValue = timeToTarget;
             }
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool TargetTimeAproximatelyReached()
             {
                 if (!Target.HasValue)
@@ -237,6 +248,7 @@ public void ResetTo(T targetValue, double serverTime)
             InternalReset(targetValue, serverTime);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void InternalReset(T targetValue, double serverTime, bool addMeasurement = true)
         {
             m_RateOfChange = default;
@@ -271,7 +283,7 @@ private void TryConsumeFromBuffer(double renderTime, double minDeltaTime, double
             {
                 if (!InterpolateState.TargetReached)
                 {
-                    InterpolateState.TargetReached = IsAproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item);
+                    InterpolateState.TargetReached = IsApproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, GetPrecision());
                 }
                 return;
             }
@@ -291,7 +303,7 @@ private void TryConsumeFromBuffer(double renderTime, double minDeltaTime, double
                     potentialItemNeedsProcessing = ((potentialItem.TimeSent <= renderTime) && potentialItem.TimeSent > InterpolateState.Target.Value.TimeSent);
                     if (!InterpolateState.TargetReached)
                     {
-                        InterpolateState.TargetReached = IsAproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item);
+                        InterpolateState.TargetReached = IsApproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, GetPrecision());
                     }
                 }
 
@@ -424,6 +436,7 @@ internal T Update(float deltaTime, double tickLatencyAsTime, double minDeltaTime
         /// This version of TryConsumeFromBuffer adheres to the original BufferedLinearInterpolator buffer consumption pattern.
         /// </remarks>
         /// <param name="renderTime"></param>
+        /// <param name="serverTime"></param>
         private void TryConsumeFromBuffer(double renderTime, double serverTime)
         {
             if (!InterpolateState.Target.HasValue || (InterpolateState.Target.Value.TimeSent <= renderTime))
@@ -433,14 +446,16 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)
                 while (m_BufferQueue.TryPeek(out BufferedItem potentialItem))
                 {
                     // If we are still on the same buffered item (FIFO Queue), then exit early as there is nothing
-                    // to consume.
+                    // to consume. (just a safety check but this scenario should never happen based on the below legacy approach of
+                    // consuming until the most current state)
                     if (previousItem.HasValue && previousItem.Value.TimeSent == potentialItem.TimeSent)
                     {
                         break;
                     }
 
-                    if ((potentialItem.TimeSent <= serverTime) &&
-                        (!InterpolateState.Target.HasValue || InterpolateState.Target.Value.TimeSent < potentialItem.TimeSent))
+                    // Continue to processing until we reach the most current state
+                    if ((potentialItem.TimeSent <= serverTime) && // Inverted logic (below) from original since we have to go from past to present
+                        (!InterpolateState.Target.HasValue || potentialItem.TimeSent > InterpolateState.Target.Value.TimeSent))
                     {
                         if (m_BufferQueue.TryDequeue(out BufferedItem target))
                         {
@@ -449,6 +464,7 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)
                                 InterpolateState.Target = target;
                                 alreadyHasBufferItem = true;
                                 InterpolateState.NextValue = InterpolateState.CurrentValue;
+                                InterpolateState.PreviousValue = InterpolateState.CurrentValue;
                                 InterpolateState.StartTime = target.TimeSent;
                                 InterpolateState.EndTime = target.TimeSent;
                             }
@@ -458,19 +474,15 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)
                                 {
                                     alreadyHasBufferItem = true;
                                     InterpolateState.StartTime = InterpolateState.Target.Value.TimeSent;
-                                    InterpolateState.NextValue = InterpolateState.CurrentValue;
+                                    InterpolateState.PreviousValue = InterpolateState.NextValue;
                                     InterpolateState.TargetReached = false;
                                 }
                                 InterpolateState.EndTime = target.TimeSent;
-                                InterpolateState.Target = target;
                                 InterpolateState.TimeToTargetValue = InterpolateState.EndTime - InterpolateState.StartTime;
+                                InterpolateState.Target = target;
                             }
                         }
                     }
-                    else
-                    {
-                        break;
-                    }
 
                     if (!InterpolateState.Target.HasValue)
                     {
@@ -505,19 +517,20 @@ public T Update(float deltaTime, double renderTime, double serverTime)
                     InterpolateState.LerpT = Math.Clamp((float)((renderTime - InterpolateState.StartTime) / InterpolateState.TimeToTargetValue), 0.0f, 1.0f);
                 }
 
-                var target = Interpolate(InterpolateState.NextValue, InterpolateState.Target.Value.Item, InterpolateState.LerpT);
+                InterpolateState.NextValue = Interpolate(InterpolateState.PreviousValue, InterpolateState.Target.Value.Item, InterpolateState.LerpT);
 
                 if (LerpSmoothEnabled)
                 {
                     // Assure our MaximumInterpolationTime is valid and that the second lerp time ranges between deltaTime and 1.0f.
-                    InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, target, deltaTime / MaximumInterpolationTime);
+                    InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, InterpolateState.NextValue, deltaTime / MaximumInterpolationTime);
                 }
                 else
                 {
-                    InterpolateState.CurrentValue = target;
+                    InterpolateState.CurrentValue = InterpolateState.NextValue;
                 }
+
                 // Determine if we have reached our target
-                InterpolateState.TargetReached = IsAproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item);
+                InterpolateState.TargetReached = IsApproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, GetPrecision());
             }
             else // If the target is reached and we have no more state updates, we want to check to see if we need to reset.
             if (m_BufferQueue.Count == 0 && InterpolateState.TargetReached)
@@ -601,6 +614,7 @@ public void AddMeasurement(T newMeasurement, double sentTime)
         /// Gets latest value from the interpolator. This is updated every update as time goes by.
         /// </summary>
         /// <returns>The current interpolated value of type 'T'</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public T GetInterpolatedValue()
         {
             return InterpolateState.CurrentValue;
@@ -638,6 +652,7 @@ public T GetInterpolatedValue()
         /// <param name="deltaTime">The increasing delta time from when start to finish.</param>
         /// <param name="maxSpeed">Maximum rate of change per pass.</param>
         /// <returns>The smoothed <see cref="T"/> value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private protected virtual T SmoothDamp(T current, T target, ref T rateOfChange, float duration, float deltaTime, float maxSpeed = Mathf.Infinity)
         {
             return target;
@@ -653,7 +668,8 @@ private protected virtual T SmoothDamp(T current, T target, ref T rateOfChange,
         /// <param name="second">Second value of type <see cref="T"/>.</param>
         /// <param name="precision">The precision of the aproximation.</param>
         /// <returns>true if the two values are aproximately the same and false if they are not</returns>
-        private protected virtual bool IsAproximately(T first, T second, float precision = k_AproximatePrecision)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private protected virtual bool IsApproximately(T first, T second, float precision = k_ApproximateLowPrecision)
         {
             return false;
         }
@@ -665,6 +681,7 @@ private protected virtual bool IsAproximately(T first, T second, float precision
         /// <param name="item">The item to convert.</param>
         /// <param name="inLocalSpace">local or world space (true or false).</param>
         /// <returns>The converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         protected internal virtual T OnConvertTransformSpace(Transform transform, T item, bool inLocalSpace)
         {
             return default;
@@ -675,6 +692,7 @@ protected internal virtual T OnConvertTransformSpace(Transform transform, T item
         /// </summary>
         /// <param name="transform">The transform that the <see cref="Components.NetworkTransform"/> is associated with.</param>
         /// <param name="inLocalSpace">Whether the <see cref="Components.NetworkTransform"/> is now being tracked in local or world spaced.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void ConvertTransformSpace(Transform transform, bool inLocalSpace)
         {
             var count = m_BufferQueue.Count;
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolatorFloat.cs b/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolatorFloat.cs
@@ -25,7 +25,7 @@ protected override float Interpolate(float start, float end, float time)
 
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private protected override bool IsAproximately(float first, float second, float precision = 1E-07F)
+        private protected override bool IsApproximately(float first, float second, float precision = 1E-06F)
         {
             return Mathf.Approximately(first, second);
         }
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolatorQuaternion.cs b/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolatorQuaternion.cs
@@ -66,7 +66,7 @@ private protected override Quaternion SmoothDamp(Quaternion current, Quaternion
 
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private protected override bool IsAproximately(Quaternion first, Quaternion second, float precision)
+        private protected override bool IsApproximately(Quaternion first, Quaternion second, float precision = 1E-06F)
         {
             return Mathf.Abs(first.x - second.x) <= precision &&
                 Mathf.Abs(first.y - second.y) <= precision &&
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolatorVector3.cs b/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolatorVector3.cs
@@ -59,7 +59,7 @@ protected internal override Vector3 OnConvertTransformSpace(Transform transform,
 
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private protected override bool IsAproximately(Vector3 first, Vector3 second, float precision = 0.0001F)
+        private protected override bool IsApproximately(Vector3 first, Vector3 second, float precision = 1E-06F)
         {
             return Math.Round(Mathf.Abs(first.x - second.x), 2) <= precision &&
                 Math.Round(Mathf.Abs(first.y - second.y), 2) <= precision &&
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs b/com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs
@@ -968,6 +968,8 @@ public enum InterpolationTypes
             /// <item><description>The first phase lerps from the previous state update value to the next state update value.</description></item>
             /// <item><description>The second phase (optional) performs lerp smoothing where the current respective transform value is lerped towards the result of the first phase at a rate of delta time divided by the respective max interpolation time.</description></item>
             /// </list>
+            /// !!! NOTE !!!<br />
+            /// The legacy lerp interpolation type does not use <see cref="NetworkTimeSystem.TickLatency"/> to determine the buffer depth. This is to preserve the same interpolation results when lerp smoothing is enabled.<br />
             /// </summary>
             /// <remarks>
             /// For more information:<br />
@@ -4085,6 +4087,17 @@ private void UpdateInterpolation()
                 }
             }
 
+            // Note: This is for the legacy lerp type in order to maintain the same end result for any games under development that have tuned their
+            // project's to match the legacy lerp's end result. This will not allow changes
+            var cachedRenderTime = 0.0;
+            if (PositionInterpolationType == InterpolationTypes.LegacyLerp || RotationInterpolationType == InterpolationTypes.LegacyLerp || ScaleInterpolationType == InterpolationTypes.LegacyLerp)
+            {
+                // Since InterpolationBufferTickOffset defaults to zero, this should not impact exist projects but still provides users with the ability to tweak
+                // their ticks ago time. 
+                var ticksAgo = (!IsServerAuthoritative() && !IsServer ? 2 : 1) + InterpolationBufferTickOffset;
+                cachedRenderTime = timeSystem.TimeTicksAgo(ticksAgo).Time;
+            }
+
             // Get the tick latency (ticks ago) as time (in the past) to process state updates in the queue.
             var tickLatencyAsTime = timeSystem.TimeTicksAgo(tickLatency).Time;
 
@@ -4127,7 +4140,7 @@ private void UpdateInterpolation()
 
                 if (PositionInterpolationType == InterpolationTypes.LegacyLerp)
                 {
-                    m_PositionInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, currentTime);
+                    m_PositionInterpolator.Update(cachedDeltaTime, cachedRenderTime, currentTime);
                 }
                 else
                 {
@@ -4158,7 +4171,7 @@ private void UpdateInterpolation()
                 m_RotationInterpolator.IsSlerp = !UseHalfFloatPrecision;
                 if (RotationInterpolationType == InterpolationTypes.LegacyLerp)
                 {
-                    m_RotationInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, currentTime);
+                    m_RotationInterpolator.Update(cachedDeltaTime, cachedRenderTime, currentTime);
                 }
                 else
                 {
@@ -4186,7 +4199,7 @@ private void UpdateInterpolation()
 
                 if (ScaleInterpolationType == InterpolationTypes.LegacyLerp)
                 {
-                    m_ScaleInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, currentTime);
+                    m_ScaleInterpolator.Update(cachedDeltaTime, cachedRenderTime, currentTime);
                 }
                 else
                 {

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Runtime.CompilerServices;`
`3`	`4`	`using UnityEngine;`
`4`	`5`
`5`	`6`	`namespace Unity.Netcode`
`@@ -14,9 +15,16 @@ public abstract class BufferedLinearInterpolator<T> where T : struct`
`14`	`15`	`// Constant absolute value for max buffer count instead of dynamic time based value. This is in case we have very low tick rates, so`
`15`	`16`	`// that we don't have a very small buffer because of this.`
`16`	`17`	`private const int k_BufferCountLimit = 100;`
`17`		`- private const float k_AproximatePrecision = 0.0001f;`
	`18`	`+ private const float k_ApproximateLowPrecision = 0.000001f;`
	`19`	`+ private const float k_ApproximateHighPrecision = 1E-10f;`
`18`	`20`	`private const double k_SmallValue = 9.999999439624929E-11; // copied from Vector3's equal operator`
`19`	`21`
	`22`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`23`	`+ private float GetPrecision()`
	`24`	`+ {`
	`25`	`+ return m_BufferQueue.Count == 0 ? k_ApproximateHighPrecision : k_ApproximateLowPrecision;`
	`26`	`+ }`
	`27`	`+`
`20`	`28`	`#region Legacy notes`
`21`	`29`	`// Buffer consumption scenarios`
`22`	`30`	`// Perfect case consumption`
`@@ -132,20 +140,23 @@ internal struct CurrentState`
`132`	`140`	`public float CurrentDeltaTime => m_CurrentDeltaTime;`
`133`	`141`	`public double FinalTimeToTarget => Math.Max(0.0, TimeToTargetValue - DeltaTime);`
`134`	`142`
	`143`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`135`	`144`	`public void AddDeltaTime(float deltaTime)`
`136`	`145`	`{`
`137`	`146`	`m_CurrentDeltaTime = deltaTime;`
`138`	`147`	`DeltaTime = Math.Min(DeltaTime + deltaTime, TimeToTargetValue);`
`139`	`148`	`LerpT = (float)(TimeToTargetValue == 0.0 ? 1.0 : DeltaTime / TimeToTargetValue);`
`140`	`149`	`}`
`141`	`150`
	`151`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`142`	`152`	`public void SetTimeToTarget(double timeToTarget)`
`143`	`153`	`{`
`144`	`154`	`LerpT = 0.0f;`
`145`	`155`	`DeltaTime = 0.0f;`
`146`	`156`	`TimeToTargetValue = timeToTarget;`
`147`	`157`	`}`
`148`	`158`
	`159`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`149`	`160`	`public bool TargetTimeAproximatelyReached()`
`150`	`161`	`{`
`151`	`162`	`if (!Target.HasValue)`
`@@ -237,6 +248,7 @@ public void ResetTo(T targetValue, double serverTime)`
`237`	`248`	`InternalReset(targetValue, serverTime);`
`238`	`249`	`}`
`239`	`250`
	`251`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`240`	`252`	`private void InternalReset(T targetValue, double serverTime, bool addMeasurement = true)`
`241`	`253`	`{`
`242`	`254`	`m_RateOfChange = default;`
`@@ -271,7 +283,7 @@ private void TryConsumeFromBuffer(double renderTime, double minDeltaTime, double`
`271`	`283`	`{`
`272`	`284`	`if (!InterpolateState.TargetReached)`
`273`	`285`	`{`
`274`		`- InterpolateState.TargetReached = IsAproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item);`
	`286`	`+ InterpolateState.TargetReached = IsApproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, GetPrecision());`
`275`	`287`	`}`
`276`	`288`	`return;`
`277`	`289`	`}`
`@@ -291,7 +303,7 @@ private void TryConsumeFromBuffer(double renderTime, double minDeltaTime, double`
`291`	`303`	`potentialItemNeedsProcessing = ((potentialItem.TimeSent <= renderTime) && potentialItem.TimeSent > InterpolateState.Target.Value.TimeSent);`
`292`	`304`	`if (!InterpolateState.TargetReached)`
`293`	`305`	`{`
`294`		`- InterpolateState.TargetReached = IsAproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item);`
	`306`	`+ InterpolateState.TargetReached = IsApproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, GetPrecision());`
`295`	`307`	`}`
`296`	`308`	`}`
`297`	`309`
`@@ -424,6 +436,7 @@ internal T Update(float deltaTime, double tickLatencyAsTime, double minDeltaTime`
`424`	`436`	`/// This version of TryConsumeFromBuffer adheres to the original BufferedLinearInterpolator buffer consumption pattern.`
`425`	`437`	`/// </remarks>`
`426`	`438`	`/// <param name="renderTime"></param>`
	`439`	`+ /// <param name="serverTime"></param>`
`427`	`440`	`private void TryConsumeFromBuffer(double renderTime, double serverTime)`
`428`	`441`	`{`
`429`	`442`	`if (!InterpolateState.Target.HasValue \|\| (InterpolateState.Target.Value.TimeSent <= renderTime))`
`@@ -433,14 +446,16 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)`
`433`	`446`	`while (m_BufferQueue.TryPeek(out BufferedItem potentialItem))`
`434`	`447`	`{`
`435`	`448`	`// If we are still on the same buffered item (FIFO Queue), then exit early as there is nothing`
`436`		`- // to consume.`
	`449`	`+ // to consume. (just a safety check but this scenario should never happen based on the below legacy approach of`
	`450`	`+ // consuming until the most current state)`
`437`	`451`	`if (previousItem.HasValue && previousItem.Value.TimeSent == potentialItem.TimeSent)`
`438`	`452`	`{`
`439`	`453`	`break;`
`440`	`454`	`}`
`441`	`455`
`442`		`- if ((potentialItem.TimeSent <= serverTime) &&`
`443`		`- (!InterpolateState.Target.HasValue \|\| InterpolateState.Target.Value.TimeSent < potentialItem.TimeSent))`
	`456`	`+ // Continue to processing until we reach the most current state`
	`457`	`+ if ((potentialItem.TimeSent <= serverTime) && // Inverted logic (below) from original since we have to go from past to present`
	`458`	`+ (!InterpolateState.Target.HasValue \|\| potentialItem.TimeSent > InterpolateState.Target.Value.TimeSent))`
`444`	`459`	`{`
`445`	`460`	`if (m_BufferQueue.TryDequeue(out BufferedItem target))`
`446`	`461`	`{`
`@@ -449,6 +464,7 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)`
`449`	`464`	`InterpolateState.Target = target;`
`450`	`465`	`alreadyHasBufferItem = true;`
`451`	`466`	`InterpolateState.NextValue = InterpolateState.CurrentValue;`
	`467`	`+ InterpolateState.PreviousValue = InterpolateState.CurrentValue;`
`452`	`468`	`InterpolateState.StartTime = target.TimeSent;`
`453`	`469`	`InterpolateState.EndTime = target.TimeSent;`
`454`	`470`	`}`
`@@ -458,19 +474,15 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)`
`458`	`474`	`{`
`459`	`475`	`alreadyHasBufferItem = true;`
`460`	`476`	`InterpolateState.StartTime = InterpolateState.Target.Value.TimeSent;`
`461`		`- InterpolateState.NextValue = InterpolateState.CurrentValue;`
	`477`	`+ InterpolateState.PreviousValue = InterpolateState.NextValue;`
`462`	`478`	`InterpolateState.TargetReached = false;`
`463`	`479`	`}`
`464`	`480`	`InterpolateState.EndTime = target.TimeSent;`
`465`		`- InterpolateState.Target = target;`
`466`	`481`	`InterpolateState.TimeToTargetValue = InterpolateState.EndTime - InterpolateState.StartTime;`
	`482`	`+ InterpolateState.Target = target;`
`467`	`483`	`}`
`468`	`484`	`}`
`469`	`485`	`}`
`470`		`- else`
`471`		`- {`
`472`		`- break;`
`473`		`- }`
`474`	`486`
`475`	`487`	`if (!InterpolateState.Target.HasValue)`
`476`	`488`	`{`
`@@ -505,19 +517,20 @@ public T Update(float deltaTime, double renderTime, double serverTime)`
`505`	`517`	`InterpolateState.LerpT = Math.Clamp((float)((renderTime - InterpolateState.StartTime) / InterpolateState.TimeToTargetValue), 0.0f, 1.0f);`
`506`	`518`	`}`
`507`	`519`
`508`		`- var target = Interpolate(InterpolateState.NextValue, InterpolateState.Target.Value.Item, InterpolateState.LerpT);`
	`520`	`+ InterpolateState.NextValue = Interpolate(InterpolateState.PreviousValue, InterpolateState.Target.Value.Item, InterpolateState.LerpT);`
`509`	`521`
`510`	`522`	`if (LerpSmoothEnabled)`
`511`	`523`	`{`
`512`	`524`	`// Assure our MaximumInterpolationTime is valid and that the second lerp time ranges between deltaTime and 1.0f.`
`513`		`- InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, target, deltaTime / MaximumInterpolationTime);`
	`525`	`+ InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, InterpolateState.NextValue, deltaTime / MaximumInterpolationTime);`
`514`	`526`	`}`
`515`	`527`	`else`
`516`	`528`	`{`
`517`		`- InterpolateState.CurrentValue = target;`
	`529`	`+ InterpolateState.CurrentValue = InterpolateState.NextValue;`
`518`	`530`	`}`
	`531`	`+`
`519`	`532`	`// Determine if we have reached our target`
`520`		`- InterpolateState.TargetReached = IsAproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item);`
	`533`	`+ InterpolateState.TargetReached = IsApproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, GetPrecision());`
`521`	`534`	`}`
`522`	`535`	`else // If the target is reached and we have no more state updates, we want to check to see if we need to reset.`
`523`	`536`	`if (m_BufferQueue.Count == 0 && InterpolateState.TargetReached)`
`@@ -601,6 +614,7 @@ public void AddMeasurement(T newMeasurement, double sentTime)`
`601`	`614`	`/// Gets latest value from the interpolator. This is updated every update as time goes by.`
`602`	`615`	`/// </summary>`
`603`	`616`	`/// <returns>The current interpolated value of type 'T'</returns>`
	`617`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`604`	`618`	`public T GetInterpolatedValue()`
`605`	`619`	`{`
`606`	`620`	`return InterpolateState.CurrentValue;`
`@@ -638,6 +652,7 @@ public T GetInterpolatedValue()`
`638`	`652`	`/// <param name="deltaTime">The increasing delta time from when start to finish.</param>`
`639`	`653`	`/// <param name="maxSpeed">Maximum rate of change per pass.</param>`
`640`	`654`	`/// <returns>The smoothed <see cref="T"/> value.</returns>`
	`655`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`641`	`656`	`private protected virtual T SmoothDamp(T current, T target, ref T rateOfChange, float duration, float deltaTime, float maxSpeed = Mathf.Infinity)`
`642`	`657`	`{`
`643`	`658`	`return target;`
`@@ -653,7 +668,8 @@ private protected virtual T SmoothDamp(T current, T target, ref T rateOfChange,`
`653`	`668`	`/// <param name="second">Second value of type <see cref="T"/>.</param>`
`654`	`669`	`/// <param name="precision">The precision of the aproximation.</param>`
`655`	`670`	`/// <returns>true if the two values are aproximately the same and false if they are not</returns>`
`656`		`- private protected virtual bool IsAproximately(T first, T second, float precision = k_AproximatePrecision)`
	`671`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`672`	`+ private protected virtual bool IsApproximately(T first, T second, float precision = k_ApproximateLowPrecision)`
`657`	`673`	`{`
`658`	`674`	`return false;`
`659`	`675`	`}`
`@@ -665,6 +681,7 @@ private protected virtual bool IsAproximately(T first, T second, float precision`
`665`	`681`	`/// <param name="item">The item to convert.</param>`
`666`	`682`	`/// <param name="inLocalSpace">local or world space (true or false).</param>`
`667`	`683`	`/// <returns>The converted value.</returns>`
	`684`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`668`	`685`	`protected internal virtual T OnConvertTransformSpace(Transform transform, T item, bool inLocalSpace)`
`669`	`686`	`{`
`670`	`687`	`return default;`
`@@ -675,6 +692,7 @@ protected internal virtual T OnConvertTransformSpace(Transform transform, T item`
`675`	`692`	`/// </summary>`
`676`	`693`	`/// <param name="transform">The transform that the <see cref="Components.NetworkTransform"/> is associated with.</param>`
`677`	`694`	`/// <param name="inLocalSpace">Whether the <see cref="Components.NetworkTransform"/> is now being tracked in local or world spaced.</param>`
	`695`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`678`	`696`	`internal void ConvertTransformSpace(Transform transform, bool inLocalSpace)`
`679`	`697`	`{`
`680`	`698`	`var count = m_BufferQueue.Count;`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ protected override float Interpolate(float start, float end, float time)`
`25`	`25`
`26`	`26`	`/// <inheritdoc />`
`27`	`27`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`28`		`- private protected override bool IsAproximately(float first, float second, float precision = 1E-07F)`
	`28`	`+ private protected override bool IsApproximately(float first, float second, float precision = 1E-06F)`
`29`	`29`	`{`
`30`	`30`	`return Mathf.Approximately(first, second);`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ private protected override Quaternion SmoothDamp(Quaternion current, Quaternion`
`66`	`66`
`67`	`67`	`/// <inheritdoc />`
`68`	`68`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`69`		`- private protected override bool IsAproximately(Quaternion first, Quaternion second, float precision)`
	`69`	`+ private protected override bool IsApproximately(Quaternion first, Quaternion second, float precision = 1E-06F)`
`70`	`70`	`{`
`71`	`71`	`return Mathf.Abs(first.x - second.x) <= precision &&`
`72`	`72`	`Mathf.Abs(first.y - second.y) <= precision &&`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ protected internal override Vector3 OnConvertTransformSpace(Transform transform,`
`59`	`59`
`60`	`60`	`/// <inheritdoc />`
`61`	`61`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`62`		`- private protected override bool IsAproximately(Vector3 first, Vector3 second, float precision = 0.0001F)`
	`62`	`+ private protected override bool IsApproximately(Vector3 first, Vector3 second, float precision = 1E-06F)`
`63`	`63`	`{`
`64`	`64`	`return Math.Round(Mathf.Abs(first.x - second.x), 2) <= precision &&`
`65`	`65`	`Math.Round(Mathf.Abs(first.y - second.y), 2) <= precision &&`
Original file line number	Diff line number	Diff line change
`@@ -968,6 +968,8 @@ public enum InterpolationTypes`
`968`	`968`	`/// <item><description>The first phase lerps from the previous state update value to the next state update value.</description></item>`
`969`	`969`	`/// <item><description>The second phase (optional) performs lerp smoothing where the current respective transform value is lerped towards the result of the first phase at a rate of delta time divided by the respective max interpolation time.</description></item>`
`970`	`970`	`/// </list>`
	`971`	`+ /// !!! NOTE !!!<br />`
	`972`	`+ /// The legacy lerp interpolation type does not use <see cref="NetworkTimeSystem.TickLatency"/> to determine the buffer depth. This is to preserve the same interpolation results when lerp smoothing is enabled.<br />`
`971`	`973`	`/// </summary>`
`972`	`974`	`/// <remarks>`
`973`	`975`	`/// For more information:<br />`
`@@ -4085,6 +4087,17 @@ private void UpdateInterpolation()`
`4085`	`4087`	`}`
`4086`	`4088`	`}`
`4087`	`4089`
	`4090`	`+ // Note: This is for the legacy lerp type in order to maintain the same end result for any games under development that have tuned their`
	`4091`	`+ // project's to match the legacy lerp's end result. This will not allow changes`
	`4092`	`+ var cachedRenderTime = 0.0;`
	`4093`	`+ if (PositionInterpolationType == InterpolationTypes.LegacyLerp \|\| RotationInterpolationType == InterpolationTypes.LegacyLerp \|\| ScaleInterpolationType == InterpolationTypes.LegacyLerp)`
	`4094`	`+ {`
	`4095`	`+ // Since InterpolationBufferTickOffset defaults to zero, this should not impact exist projects but still provides users with the ability to tweak`
	`4096`	`+ // their ticks ago time.`
	`4097`	`+ var ticksAgo = (!IsServerAuthoritative() && !IsServer ? 2 : 1) + InterpolationBufferTickOffset;`
	`4098`	`+ cachedRenderTime = timeSystem.TimeTicksAgo(ticksAgo).Time;`
	`4099`	`+ }`
	`4100`	`+`
`4088`	`4101`	`// Get the tick latency (ticks ago) as time (in the past) to process state updates in the queue.`
`4089`	`4102`	`var tickLatencyAsTime = timeSystem.TimeTicksAgo(tickLatency).Time;`
`4090`	`4103`
`@@ -4127,7 +4140,7 @@ private void UpdateInterpolation()`
`4127`	`4140`
`4128`	`4141`	`if (PositionInterpolationType == InterpolationTypes.LegacyLerp)`
`4129`	`4142`	`{`
`4130`		`- m_PositionInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, currentTime);`
	`4143`	`+ m_PositionInterpolator.Update(cachedDeltaTime, cachedRenderTime, currentTime);`
`4131`	`4144`	`}`
`4132`	`4145`	`else`
`4133`	`4146`	`{`
`@@ -4158,7 +4171,7 @@ private void UpdateInterpolation()`
`4158`	`4171`	`m_RotationInterpolator.IsSlerp = !UseHalfFloatPrecision;`
`4159`	`4172`	`if (RotationInterpolationType == InterpolationTypes.LegacyLerp)`
`4160`	`4173`	`{`
`4161`		`- m_RotationInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, currentTime);`
	`4174`	`+ m_RotationInterpolator.Update(cachedDeltaTime, cachedRenderTime, currentTime);`
`4162`	`4175`	`}`
`4163`	`4176`	`else`
`4164`	`4177`	`{`
`@@ -4186,7 +4199,7 @@ private void UpdateInterpolation()`
`4186`	`4199`
`4187`	`4200`	`if (ScaleInterpolationType == InterpolationTypes.LegacyLerp)`
`4188`	`4201`	`{`
`4189`		`- m_ScaleInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, currentTime);`
	`4202`	`+ m_ScaleInterpolator.Update(cachedDeltaTime, cachedRenderTime, currentTime);`
`4190`	`4203`	`}`
`4191`	`4204`	`else`
`4192`	`4205`	`{`