fix: Only substitute the retention limit at a maximum interpolation time of 1.0

Clamping to k_MaximumLerpSmoothRetention flattened everything above it, so
0.995 smoothed at the same rate as 0.99 and stopped honoring "higher is
smoother". Clamp to the legal range first and substitute only at the
freezing endpoint.

Also corrects the lerp smoothing remarks: LegacyLerp still applies
deltaTime / MaximumInterpolationTime per frame, so the frame rate
independence claim only holds for Lerp and SmoothDampening.

Author: NoelStephensUnity

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

@@ -443,7 +443,11 @@ internal void ResetCurrentState()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private float GetLerpSmoothTime(float deltaTime)
         {
-            var retained = Mathf.Clamp(MaximumInterpolationTime, 0.0f, k_MaximumLerpSmoothRetention);
+            var retained = Mathf.Clamp01(MaximumInterpolationTime);
+            if (retained >= 1.0f)
+            {
+                retained = k_MaximumLerpSmoothRetention;
+            }
             return 1.0f - Mathf.Pow(retained, deltaTime * k_LerpSmoothReferenceFrameRate);
         }
 

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

@@ -1238,8 +1238,9 @@ public enum InterpolationTypes
         /// <remarks>
         /// When enabled, the <see cref="BufferedLinearInterpolator{T}"/> will apply a final lerping pass towards
         /// the interpolated result at a rate determined by <see cref="PositionMaxInterpolationTime"/>.<br />
-        /// This is frame rate independent for all <see cref="InterpolationTypes"/>, but the same value will not
-        /// produce the same result under <see cref="InterpolationTypes.LegacyLerp"/> as it does under the others.
+        /// This smoothing pass is frame rate independent under <see cref="InterpolationTypes.Lerp"/> and
+        /// <see cref="InterpolationTypes.SmoothDampening"/>. <see cref="InterpolationTypes.LegacyLerp"/> keeps its
+        /// original frame rate dependent smoothing, so the same value does not produce the same result there.
         /// </remarks>
         public bool PositionLerpSmoothing = true;
         private bool m_PreviousPositionLerpSmoothing;
@@ -1262,8 +1263,9 @@ public enum InterpolationTypes
         /// <remarks>
         /// When enabled, the <see cref="BufferedLinearInterpolator{T}"/> will apply a final lerping pass towards
         /// the interpolated result at a rate determined by <see cref="RotationMaxInterpolationTime"/>.<br />
-        /// This is frame rate independent for all <see cref="InterpolationTypes"/>, but the same value will not
-        /// produce the same result under <see cref="InterpolationTypes.LegacyLerp"/> as it does under the others.
+        /// This smoothing pass is frame rate independent under <see cref="InterpolationTypes.Lerp"/> and
+        /// <see cref="InterpolationTypes.SmoothDampening"/>. <see cref="InterpolationTypes.LegacyLerp"/> keeps its
+        /// original frame rate dependent smoothing, so the same value does not produce the same result there.
         /// </remarks>
         public bool RotationLerpSmoothing = true;
         private bool m_PreviousRotationLerpSmoothing;
@@ -1286,8 +1288,9 @@ public enum InterpolationTypes
         /// <remarks>
         /// When enabled, the <see cref="BufferedLinearInterpolator{T}"/> will apply a final lerping pass towards
         /// the interpolated result at a rate determined by <see cref="ScaleMaxInterpolationTime"/>.<br />
-        /// This is frame rate independent for all <see cref="InterpolationTypes"/>, but the same value will not
-        /// produce the same result under <see cref="InterpolationTypes.LegacyLerp"/> as it does under the others.
+        /// This smoothing pass is frame rate independent under <see cref="InterpolationTypes.Lerp"/> and
+        /// <see cref="InterpolationTypes.SmoothDampening"/>. <see cref="InterpolationTypes.LegacyLerp"/> keeps its
+        /// original frame rate dependent smoothing, so the same value does not produce the same result there.
         /// </remarks>
         public bool ScaleLerpSmoothing = true;
         private bool m_PreviousScaleLerpSmoothing;

com.unity.netcode.gameobjects/Tests/Editor/InterpolatorTests.cs

@@ -382,6 +382,22 @@ public void LerpSmoothingIsFrameRateIndependent()
                 $"{atTwoFortyFps} at 240fps. The smoothing rate is scaling with the frame rate.");
         }
 
+        /// <summary>
+        /// Only 1.0f is substituted for, so settings below it keep their own smoothing rate and a heavier
+        /// setting stays smoother than a lighter one.
+        /// </summary>
+        [Test]
+        public void LerpSmoothingPreservesSettingsBelowTheMaximum()
+        {
+            // 0.99f is the retention substituted for 1.0f, so clamping to it would collapse these two.
+            var lighter = RunLerpSmoothing(0.99f, 1.0f / 60.0f, true);
+            var heavier = RunLerpSmoothing(0.995f, 1.0f / 60.0f, true);
+
+            Assert.That(heavier, Is.LessThan(lighter),
+                $"0.995 converged to {heavier} and 0.99 to {lighter} over the same motion. A higher maximum " +
+                "interpolation time has to retain more of the previous value, so it cannot converge first.");
+        }
+
         #endregion
     }
 }