test

Renaming NetworkTransformMultipleChangesOverTime to just MultipleChangesOverTime (no need for the NetworkTransform part as it is already part of the NetworkTransformTests).
Turning off Lerp smoothing for MultipleChangesOverTime and added lengthy comment as to why.
Fixed the initial check for the first state update in MultipleChangesOverTime  due to a change in the Interpolation value. It was not properly checking both pushed and updated values and should only be checked when interpolation is turned off as the default is enabled and when running MultipleChangesOverTime  for 3 axis it remains enabled (i.e. there will be no state update for that as nothing changed).

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Tests/Runtime/NetworkTransform/NetworkTransformBase.cs

@@ -782,6 +782,7 @@ internal class NetworkTransformTestComponent : NetworkTransform
 
         protected override void OnAuthorityPushTransformState(ref NetworkTransformState networkTransformState)
         {
+            Debug.Log($"[Auth]{name} State Pushed.");
             StatePushed = true;
             AuthorityLastSentState = networkTransformState;
             AuthorityPushedTransformState?.Invoke(ref networkTransformState);
@@ -792,10 +793,41 @@ protected override void OnAuthorityPushTransformState(ref NetworkTransformState
         public bool StateUpdated { get; internal set; }
         protected override void OnNetworkTransformStateUpdated(ref NetworkTransformState oldState, ref NetworkTransformState newState)
         {
+            Debug.Log($"[Non-Auth]{name} State Updated.");
             StateUpdated = true;
             base.OnNetworkTransformStateUpdated(ref oldState, ref newState);
         }
 
+        protected string GetVector3Values(ref Vector3 vector3)
+        {
+            return $"({vector3.x:F6},{vector3.y:F6},{vector3.z:F6})";
+        }
+
+        protected string GetVector3Values(Vector3 vector3)
+        {
+            return GetVector3Values(ref vector3);
+        }
+
+        public bool EnableVerboseDebug;
+
+        public void GetInterpolatorInfo()
+        {
+            if (!EnableVerboseDebug)
+            {
+                return;
+            }
+            var positionInterpolator = GetPositionInterpolator();
+            var rotationInterpolator = GetRotationInterpolator();
+            Debug.Log($"TT: {positionInterpolator.InterpolateState.TimeToTargetValue} BuffCnt: {positionInterpolator.m_BufferQueue.Count} Pos: {GetVector3Values(positionInterpolator.InterpolateState.CurrentValue)} " +
+                $"Rot: {GetVector3Values(rotationInterpolator.InterpolateState.CurrentValue.eulerAngles)}");
+        }
+
+        public override void OnUpdate()
+        {
+            base.OnUpdate();
+            GetInterpolatorInfo();
+        }
+
         protected override bool OnIsServerAuthoritative()
         {
             return ServerAuthority;

com.unity.netcode.gameobjects/Tests/Runtime/NetworkTransform/NetworkTransformTests.cs

@@ -492,7 +492,7 @@ public void ParentedNetworkTransformTest([Values] Interpolation interpolation, [
         /// delta update, and it runs through 8 delta updates per unique test.
         /// </remarks>
         [Test]
-        public void NetworkTransformMultipleChangesOverTime([Values] TransformSpace testLocalTransform, [Values] OverrideState overideState, [Values] Axis axis)
+        public void MultipleChangesOverTime([Values] TransformSpace testLocalTransform, [Values] OverrideState overideState, [Values] Axis axis)
         {
             m_AuthoritativeTransform.InLocalSpace = testLocalTransform == TransformSpace.Local;
             bool axisX = axis == Axis.X || axis == Axis.XY || axis == Axis.XZ || axis == Axis.XYZ;
@@ -507,6 +507,30 @@ public void NetworkTransformMultipleChangesOverTime([Values] TransformSpace test
             // when interpolation is enabled.
             m_AuthoritativeTransform.Interpolate = axisCount == 3 ? true : false;
 
+            // Lerp smoothing skews values based on our tests and how we had to originally adjust for the way we handled the original Lerp approach and how that
+            // consumed state updates from the buffer.
+            // With the two new interpolation types, they will process until close to the final value before moving on to the next.
+            // Lerp--> Will skip to next state before finishing the current state (i.e. loss of precision but arrives to the final value at the end of multiple updates faster)
+            // LerpExtrapolateBlend & SmoothDampening -->
+            // Will not skip to the next state update until approximately at the end of the current state (higher precision longer time to final value)
+            // How this impacts this test:
+            // It was re-written to use TimeTravel which has a limit of 60 update iterations per "WaitforCondition" which if you are interpolating between two large values
+            // it can take a few more iterations with lerp smoothing enabled. Lerp smoothing is purely a visual thing and will eventually end up at its final destination
+            // upon processing the last state update. However, this test should be only to verify the functionality of the actual lerping between values without the added
+            // delay of smoothing the final result. So, instead of having one timeout value for the two new interpolation types and the default for the original I am opting
+            // for the disabling of lerp smoothing while this particular test runs as it really is only validating that each interpolator type will interpolate to the right
+            // value within a given period of time which is simulated using the time travel approach.
+            // With smooth lerping enabled, the two new interpolation types will come very close to the correct value but will not reach the 2nd or 3rd pass values set because
+            // this test uses the adjusted approximation checks that prematurely determines the target values (position, rotation, and scale) have been reached and as such
+            // sends a new state update that will sit in the buffer for 3-4 frames before the two new interpolation types are done with the current state update. This will
+            // eventually lead to a time deficit that will offset the processing of the next state update such that the default time travel timeout (60 updates) will timeout
+            // and the test will fail. This only happens with 3 axis since that is the only time interpolation was enabled for this particular test.
+            // As such, just disabling smooth lerping for all 3 seemed like the better approach as the maximum interpolation time out period for smooth lerping is now
+            // adjustable by users (i.e. they can adjust how much lerp smoothing is applied based on their project's needs).
+            m_NonAuthoritativeTransform.PositionLerpSmoothing = false;
+            m_NonAuthoritativeTransform.RotationLerpSmoothing = false;
+            m_NonAuthoritativeTransform.ScaleLerpSmoothing = false;
+
             m_CurrentAxis = axis;
 
             m_AuthoritativeTransform.SyncPositionX = axisX;
@@ -541,12 +565,18 @@ public void NetworkTransformMultipleChangesOverTime([Values] TransformSpace test
             var scale = scaleStart;
             var success = false;
 
-            m_AuthoritativeTransform.StatePushed = false;
-            // Wait for the deltas to be pushed
-            WaitForConditionOrTimeOutWithTimeTravel(() => m_AuthoritativeTransform.StatePushed);
-            // Allow the precision settings to propagate first as changing precision
-            // causes a teleport event to occur
-            TimeTravelAdvanceTick();
+            // The default is interpolate, so we only need to check for the updated state when
+            // we turn off interpolation.
+            if (!m_AuthoritativeTransform.Interpolate)
+            {
+                // Reset our state updated and state pushed
+                m_NonAuthoritativeTransform.StateUpdated = false;
+                m_AuthoritativeTransform.StatePushed = false;
+                // Wait for both authority and non-authority to update their respective flags so we know the change to interpolation has been received.
+                success = WaitForConditionOrTimeOutWithTimeTravel(() => m_AuthoritativeTransform.StatePushed && m_NonAuthoritativeTransform.StateUpdated);
+                Assert.True(success, "Failed to wait for interpolation changed state update!");
+            }
+
             var iterations = axisCount == 3 ? k_PositionRotationScaleIterations3Axis : k_PositionRotationScaleIterations;
 
             // Move and rotate within the same tick, validate the non-authoritative instance updates
@@ -595,6 +625,7 @@ public void NetworkTransformMultipleChangesOverTime([Values] TransformSpace test
                     if (!success)
                     {
                         m_EnableVerboseDebug = true;
+                        VerboseDebug($"Failed on iteration: {i}");
                         success = PositionRotationScaleMatches();
                         m_EnableVerboseDebug = false;
                     }