fix: correct interpolation of NetworkTransform upon space change (#1744)

* fix: initial, naive, fix for localspace change in NetworkTransport. Not working. Also includes test that shows it is not working

* fix: clearing the interpolator upon receive

* fix: reset to position instead of just clearing buffers, upon interpolation space change

* restoring unintended comment change

* test: improving the interpolation test

* removing the interpolation test as it exposes a different issue

* improved fix, added test back

* style: readability

* test: test improvements

* test: removing left-over code

Author: jeffreyrainy

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

@@ -260,9 +260,10 @@ public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReade
         /// </summary>
         [Tooltip("Sets whether this transform should sync in local space or in world space")]
         public bool InLocalSpace = false;
+        private bool m_LastInterpolateLocal = false; // was the last frame local
 
         public bool Interpolate = true;
-        private bool m_LastInterpolate = true;
+        private bool m_LastInterpolate = true; // was the last frame interpolated
 
         /// <summary>
         /// Used to determine who can write to this transform. Server only for this transform.
@@ -613,10 +614,46 @@ private void ApplyInterpolatedNetworkStateToTransform(NetworkTransformState netw
             }
         }
 
-        private void AddInterpolatedState(NetworkTransformState newState)
+        private void AddInterpolatedState(NetworkTransformState newState, bool reset = false)
         {
             var sentTime = newState.SentTime;
 
+            if (reset)
+            {
+                if (newState.HasPositionX)
+                {
+                    m_PositionXInterpolator.ResetTo(newState.PositionX, sentTime);
+                }
+
+                if (newState.HasPositionY)
+                {
+                    m_PositionYInterpolator.ResetTo(newState.PositionY, sentTime);
+                }
+
+                if (newState.HasPositionZ)
+                {
+                    m_PositionZInterpolator.ResetTo(newState.PositionZ, sentTime);
+                }
+
+                m_RotationInterpolator.ResetTo(Quaternion.Euler(newState.Rotation), sentTime);
+
+                if (newState.HasScaleX)
+                {
+                    m_ScaleXInterpolator.ResetTo(newState.ScaleX, sentTime);
+                }
+
+                if (newState.HasScaleY)
+                {
+                    m_ScaleYInterpolator.ResetTo(newState.ScaleY, sentTime);
+                }
+
+                if (newState.HasScaleZ)
+                {
+                    m_ScaleZInterpolator.ResetTo(newState.ScaleZ, sentTime);
+                }
+
+                return;
+            }
             if (newState.HasPositionX)
             {
                 m_PositionXInterpolator.AddMeasurement(newState.PositionX, sentTime);
@@ -668,8 +705,9 @@ private void OnNetworkStateChanged(NetworkTransformState oldState, NetworkTransf
 
             if (Interpolate)
             {
-                AddInterpolatedState(newState);
+                AddInterpolatedState(newState, (newState.InLocalSpace != m_LastInterpolateLocal));
             }
+            m_LastInterpolateLocal = newState.InLocalSpace;
 
             if (m_CachedNetworkManager.LogLevel == LogLevel.Developer)
             {

com.unity.netcode.gameobjects/Tests/Runtime/TransformInterpolationTests.cs

@@ -0,0 +1,134 @@
+using System;
+using System.Collections;
+using Unity.Netcode.Components;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    public class TransformInterpolationObject : NetworkBehaviour
+    {
+        public bool CheckPosition;
+        public bool IsMoving;
+        public bool IsFixed;
+
+        private void Update()
+        {
+            // Check the position of the nested object on the client
+            if (CheckPosition)
+            {
+                if (transform.position.y < 0.0f || transform.position.y > 100.0f)
+                {
+                    Debug.LogError($"Interpolation failure. transform.position.y is {transform.position.y}. Should be between 0.0 and 100.0");
+                }
+            }
+
+            // Move the nested object on the server
+            if (IsMoving)
+            {
+                var y = Time.realtimeSinceStartup;
+                while (y > 10.0f)
+                {
+                    y -= 10.0f;
+                }
+
+                // change the space between local and global every second
+                GetComponent<NetworkTransform>().InLocalSpace = ((int)y % 2 == 0);
+
+                transform.position = new Vector3(0.0f, y * 10, 0.0f);
+            }
+
+            // On the server, make sure to keep the parent object at a fixed position
+            if (IsFixed)
+            {
+                transform.position = new Vector3(1000.0f, 1000.0f, 1000.0f);
+            }
+        }
+    }
+
+    public class TransformInterpolationTests : BaseMultiInstanceTest
+    {
+        protected override int NbClients => 1;
+
+        private ulong m_ClientId0;
+        private GameObject m_PrefabToSpawn;
+
+        private NetworkObject m_AsNetworkObject;
+        private NetworkObject m_SpawnedObjectOnClient;
+
+        [UnitySetUp]
+        public override IEnumerator Setup()
+        {
+            yield return StartSomeClientsAndServerWithPlayers(useHost: true, nbClients: NbClients,
+                updatePlayerPrefab: playerPrefab =>
+                {
+                    m_PrefabToSpawn = PreparePrefab(typeof(TransformInterpolationObject));
+                });
+        }
+
+        private IEnumerator RefreshNetworkObjects()
+        {
+            var serverClientPlayerResult = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
+            yield return MultiInstanceHelpers.Run(
+                MultiInstanceHelpers.GetNetworkObjectByRepresentation(
+                    x => x.NetworkObjectId == m_AsNetworkObject.NetworkObjectId,
+                    m_ClientNetworkManagers[0],
+                    serverClientPlayerResult));
+            m_SpawnedObjectOnClient = serverClientPlayerResult.Result;
+
+            // make sure the objects are set with the right network manager
+            m_SpawnedObjectOnClient.NetworkManagerOwner = m_ClientNetworkManagers[0];
+        }
+
+        public GameObject PreparePrefab(Type type)
+        {
+            var prefabToSpawn = new GameObject();
+            prefabToSpawn.AddComponent(type);
+            prefabToSpawn.AddComponent<NetworkTransform>();
+            var networkObjectPrefab = prefabToSpawn.AddComponent<NetworkObject>();
+            MultiInstanceHelpers.MakeNetworkObjectTestPrefab(networkObjectPrefab);
+            m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn });
+            foreach (var clientNetworkManager in m_ClientNetworkManagers)
+            {
+                clientNetworkManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn });
+            }
+            return prefabToSpawn;
+        }
+
+        [UnityTest]
+        public IEnumerator TransformInterpolationTest()
+        {
+            m_ClientId0 = m_ClientNetworkManagers[0].LocalClientId;
+
+            // create an object
+            var spawnedObject = UnityEngine.Object.Instantiate(m_PrefabToSpawn);
+            var baseObject = UnityEngine.Object.Instantiate(m_PrefabToSpawn);
+            baseObject.GetComponent<NetworkObject>().NetworkManagerOwner = m_ServerNetworkManager;
+            baseObject.GetComponent<NetworkObject>().Spawn();
+
+            m_AsNetworkObject = spawnedObject.GetComponent<NetworkObject>();
+            m_AsNetworkObject.NetworkManagerOwner = m_ServerNetworkManager;
+
+            m_AsNetworkObject.TrySetParent(baseObject);
+
+            m_AsNetworkObject.Spawn();
+
+            yield return RefreshNetworkObjects();
+
+            m_AsNetworkObject.TrySetParent(baseObject);
+
+            baseObject.GetComponent<TransformInterpolationObject>().IsFixed = true;
+            spawnedObject.GetComponent<TransformInterpolationObject>().IsMoving = true;
+
+            // Give two seconds for the object to settle
+            yield return new WaitForSeconds(2.0f);
+
+            m_SpawnedObjectOnClient.GetComponent<TransformInterpolationObject>().CheckPosition = true;
+
+            // Test that interpolation works correctly for 10 seconds
+            // Increasing this duration gives you the opportunity to go check in the Editor how the objects are setup
+            // and how they move
+            yield return new WaitForSeconds(10.0f);
+        }
+    }
+}