test

Removing some of the debug information.
Fixing whitespace issue.
Adding a smooth lerp and non-smooth lerp pass.

Author: NoelStephensUnity

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

@@ -632,27 +632,13 @@ protected bool PositionsMatchesValue(Vector3 positionToMatch)
             var nonAuthorityPosition = m_NonAuthoritativeTransform.transform.position;
             var auhtorityIsEqual = Approximately(authorityPosition, positionToMatch);
             var nonauthorityIsEqual = Approximately(nonAuthorityPosition, positionToMatch);
-            var authorityTimeAndTick = string.Empty;
-            var nonAuthorityTimeAndTick = string.Empty;
-
-            if (m_AuthoritativeTransform.NetworkManager)
-            {
-                var authTime = m_AuthoritativeTransform.NetworkManager.LocalTime;
-                authorityTimeAndTick = $"[{authTime.Time}[{authTime.Tick}]]";
-            }
-            if (m_NonAuthoritativeTransform.NetworkManager)
-            {
-                var nonAuthTime = m_NonAuthoritativeTransform.NetworkManager.LocalTime;
-                nonAuthorityTimeAndTick = $"[{nonAuthTime.Time}[{nonAuthTime.Tick}]]";
-            }
-
             if (!auhtorityIsEqual)
             {
-                VerboseDebug($"[{authorityTimeAndTick}] Authority position {authorityPosition} != position to match: {positionToMatch} [{nonAuthorityTimeAndTick}]!");
+                VerboseDebug($"Authority ({m_AuthoritativeTransform.name}) position {authorityPosition} != position to match: {positionToMatch}!");
             }
             if (!nonauthorityIsEqual)
             {
-                VerboseDebug($"[{authorityTimeAndTick}] NonAuthority position {nonAuthorityPosition} != position to match: {positionToMatch} [{nonAuthorityTimeAndTick}]!");
+                VerboseDebug($"NonAuthority ({m_NonAuthoritativeTransform.name}) position {nonAuthorityPosition} != position to match: {positionToMatch}!");
             }
             return auhtorityIsEqual && nonauthorityIsEqual;
         }

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

@@ -12,6 +12,12 @@ namespace Unity.Netcode.RuntimeTests
     [TestFixture(HostOrServer.Host, Authority.ServerAuthority, NetworkTransform.InterpolationTypes.LerpExtrapolateBlend)]
     internal class NetworkTransformGeneral : NetworkTransformBase
     {
+        public enum SmoothLerpSettings
+        {
+            SmoothLerp,
+            NormalLerp
+        }
+
         public NetworkTransformGeneral(HostOrServer testWithHost, Authority authority, NetworkTransform.InterpolationTypes interpolationType) :
             base(testWithHost, authority, RotationCompression.None, Rotation.Euler, Precision.Full)
         {
@@ -281,38 +287,39 @@ public void TestMultipleExplicitSetStates([Values] Interpolation interpolation)
         /// This also tests that the original server authoritative model with client-owner driven NetworkTransforms is preserved.
         /// </remarks>
         [Test]
-        public void NonAuthorityOwnerSettingStateTest([Values] Interpolation interpolation)
+        public void NonAuthorityOwnerSettingStateTest([Values] Interpolation interpolation, [Values] SmoothLerpSettings smoothLerp)
         {
             var interpolate = interpolation == Interpolation.EnableInterpolate;
+            var usingSmoothLerp = (smoothLerp == SmoothLerpSettings.SmoothLerp) && interpolate;
+            var waitForDelay = usingSmoothLerp ? 1000 : 500;
+            m_NonAuthoritativeTransform.PositionLerpSmoothing = usingSmoothLerp;
+            m_NonAuthoritativeTransform.RotationLerpSmoothing = usingSmoothLerp;
+            m_NonAuthoritativeTransform.ScaleLerpSmoothing = usingSmoothLerp;
+
             m_AuthoritativeTransform.Interpolate = interpolate;
             m_NonAuthoritativeTransform.Interpolate = interpolate;
             m_NonAuthoritativeTransform.RotAngleThreshold = m_AuthoritativeTransform.RotAngleThreshold = 0.1f;
 
             m_EnableVerboseDebug = true;
             VerboseDebug($"Target Frame Rate: {Application.targetFrameRate}");
-            //m_AuthoritativeTransform.Teleport(Vector3.zero, Quaternion.identity, Vector3.one);
-            //TimeTravelAdvanceTick();
-            //var success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionRotationScaleMatches(Vector3.zero, Quaternion.identity.eulerAngles, Vector3.one), 800);
-            //Assert.True(success, $"Timed out waiting for initialization to be applied!");
-
             // Test one parameter at a time first
-            var newPosition = new Vector3(15f,-12f, 10f);
+            var newPosition = usingSmoothLerp ? new Vector3(15f, -12f, 10f) : new Vector3(55f, -24f, 20f);
             var newRotation = Quaternion.Euler(1, 2, 3);
             var newScale = new Vector3(2.0f, 2.0f, 2.0f);
             m_NonAuthoritativeTransform.SetState(newPosition, null, null, interpolate);
-            var success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionsMatchesValue(newPosition), 1000);
+            var success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionsMatchesValue(newPosition), waitForDelay);
             Assert.True(success, $"Timed out waiting for non-authoritative position state request to be applied!\n {VerboseDebugLog}");
             Assert.True(Approximately(newPosition, m_AuthoritativeTransform.transform.position), "Authoritative position does not match!");
             Assert.True(Approximately(newPosition, m_NonAuthoritativeTransform.transform.position), "Non-Authoritative position does not match!");
             m_NonAuthoritativeTransform.SetState(null, newRotation, null, interpolate);
-            success = WaitForConditionOrTimeOutWithTimeTravel(() => RotationMatchesValue(newRotation.eulerAngles), 1000);
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => RotationMatchesValue(newRotation.eulerAngles), waitForDelay);
             Assert.True(success, $"Timed out waiting for non-authoritative rotation state request to be applied!\n {VerboseDebugLog}");
             Assert.True(Approximately(newRotation.eulerAngles, m_AuthoritativeTransform.transform.rotation.eulerAngles), $"Authoritative rotation does not match!\n {VerboseDebugLog}");
             Assert.True(Approximately(newRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), $"Non-Authoritative rotation does not match!\n {VerboseDebugLog}");
             Assert.True(Approximately(newRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), $"Non-Authoritative rotation does not match!\n {VerboseDebugLog}");
 
             m_NonAuthoritativeTransform.SetState(null, null, newScale, interpolate);
-            success = WaitForConditionOrTimeOutWithTimeTravel(() => ScaleMatchesValue(newScale), 1000);
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => ScaleMatchesValue(newScale), waitForDelay);
             Assert.True(success, $"Timed out waiting for non-authoritative scale state request to be applied!\n {VerboseDebugLog}");
             Assert.True(Approximately(newScale, m_AuthoritativeTransform.transform.localScale), $"Authoritative scale does not match!\n {VerboseDebugLog}");
             Assert.True(Approximately(newScale, m_NonAuthoritativeTransform.transform.localScale), $"Non-Authoritative scale does not match!\n {VerboseDebugLog}");
@@ -323,7 +330,7 @@ public void NonAuthorityOwnerSettingStateTest([Values] Interpolation interpolati
             newScale = new Vector3(0.5f, 0.5f, 0.5f);
 
             m_NonAuthoritativeTransform.SetState(newPosition, newRotation, newScale, interpolate);
-            success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionRotationScaleMatches(newPosition, newRotation.eulerAngles, newScale), 1000);
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionRotationScaleMatches(newPosition, newRotation.eulerAngles, newScale), waitForDelay);
             Assert.True(success, $"Timed out waiting for non-authoritative position, rotation, and scale state request to be applied!\n {VerboseDebugLog}");
             Assert.True(Approximately(newPosition, m_AuthoritativeTransform.transform.position), $"Authoritative position does not match!\n {VerboseDebugLog}");
             Assert.True(Approximately(newPosition, m_NonAuthoritativeTransform.transform.position), $"Non-Authoritative position does not match!\n {VerboseDebugLog}");