update

Exposing internal access to position and rotation interpolators for future tests and tools.
Noticed the slerp for full precision rotation was only being applied when using Lerp, now it is for all interpolation types.
Making the time to approximately reach adjustment be the default when there is no pending item to be consumed and slightly sooner when there is.
Removing the adjustment to the slerp smoothing as this should be a consistantly applied value for all interpolation types.

Author: NoelStephensUnity

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

@@ -335,7 +335,7 @@ private void TryConsumeFromBuffer(double renderTime, double minDeltaTime, double
                 if (!noStateSet)
                 {
                     potentialItemNeedsProcessing = (potentialItem.TimeSent <= renderTime) && potentialItem.TimeSent >= InterpolateState.Target.Value.TimeSent;
-                    currentTargetTimeReached = InterpolateState.TargetTimeAproximatelyReached(potentialItemNeedsProcessing ? 1.0f : 0.85f) || InterpolateState.TargetReached;
+                    currentTargetTimeReached = InterpolateState.TargetTimeAproximatelyReached(potentialItemNeedsProcessing ? 1.15f : 1.0f) || InterpolateState.TargetReached;
                     if (!InterpolateState.TargetReached)
                     {
                         InterpolateState.TargetReached = IsAproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item);
@@ -463,7 +463,7 @@ internal T Update(float deltaTime, double tickLatencyAsTime, double minDeltaTime
                     if (LerpSmoothEnabled)
                     {
                         // Apply the smooth lerp to the target to help smooth the final value.
-                        InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, targetValue, deltaTime / (MaximumInterpolationTime * 0.3333f));
+                        InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, targetValue, deltaTime / MaximumInterpolationTime);
                     }
                     else
                     {
@@ -574,10 +574,10 @@ public T Update(float deltaTime, double renderTime, double serverTime)
                 // The original BufferedLinearInterpolator lerping script to assure the Smooth Dampening updates do not impact
                 // this specific behavior.
                 float t = 1.0f;
-                double range = InterpolateState.EndTime - InterpolateState.StartTime;
-                if (range > k_SmallValue)
+                InterpolateState.TimeToTargetValue = InterpolateState.EndTime - InterpolateState.StartTime;
+                if (InterpolateState.TimeToTargetValue > k_SmallValue)
                 {
-                    t = (float)((renderTime - InterpolateState.StartTime) / range);
+                    t = (float)((renderTime - InterpolateState.StartTime) / InterpolateState.TimeToTargetValue);
 
                     if (t < 0.0f)
                     {

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

@@ -4045,6 +4045,15 @@ public void ClearStats()
             PositionStats.Clear();
         }
 #endif
+        internal BufferedLinearInterpolatorVector3 GetPositionInterpolator()
+        {
+            return m_PositionInterpolator;
+        }
+
+        internal BufferedLinearInterpolatorQuaternion GetRotationInterpolator()
+        {
+            return m_RotationInterpolator;
+        }
 
         // Non-Authority
         private void UpdateInterpolation()
@@ -4145,13 +4154,12 @@ private void UpdateInterpolation()
                     m_PreviousRotationLerpSmoothing = RotationLerpSmoothing;
                     m_RotationInterpolator.ResetCurrentState();
                 }
-
+                // When using half precision Lerp towards the target rotation.
+                // When using full precision Slerp towards the target rotation.
+                /// <see cref="BufferedLinearInterpolatorQuaternion.IsSlerp"/>
+                m_RotationInterpolator.IsSlerp = !UseHalfFloatPrecision;
                 if (RotationInterpolationType == InterpolationTypes.Lerp)
                 {
-                    // When using half precision Lerp towards the target rotation.
-                    // When using full precision Slerp towards the target rotation.
-                    /// <see cref="BufferedLinearInterpolatorQuaternion.IsSlerp"/>
-                    m_RotationInterpolator.IsSlerp = !UseHalfFloatPrecision;
                     m_RotationInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, currentTime);
                 }
                 else