fix: ClientNetworkTransform ownership change with half precision synchronization issues [MTT-7271]

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

@@ -23,12 +23,20 @@ public struct NetworkDeltaPosition : INetworkSerializable
         internal Vector3 DeltaPosition;
         internal int NetworkTick;
 
+        internal bool SynchronizeBase;
+
+        internal bool CollapsedDeltaIntoBase;
+
         /// <summary>
         /// The serialization implementation of <see cref="INetworkSerializable"/>
         /// </summary>
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
         {
             HalfVector3.NetworkSerialize(serializer);
+            if (SynchronizeBase)
+            {
+                serializer.SerializeValue(ref CurrentBasePosition);
+            }
         }
 
         /// <summary>
@@ -122,6 +130,7 @@ public Vector3 GetDeltaPosition()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UpdateFrom(ref Vector3 vector3, int networkTick)
         {
+            CollapsedDeltaIntoBase = false;
             NetworkTick = networkTick;
             DeltaPosition = (vector3 + PrecisionLossDelta) - CurrentBasePosition;
             for (int i = 0; i < HalfVector3.Length; i++)
@@ -136,6 +145,7 @@ public void UpdateFrom(ref Vector3 vector3, int networkTick)
                         CurrentBasePosition[i] += HalfDeltaConvertedBack[i];
                         HalfDeltaConvertedBack[i] = 0.0f;
                         DeltaPosition[i] = 0.0f;
+                        CollapsedDeltaIntoBase = true;
                     }
                 }
             }
@@ -164,6 +174,8 @@ public NetworkDeltaPosition(Vector3 vector3, int networkTick, bool3 axisToSynchr
             DeltaPosition = Vector3.zero;
             HalfDeltaConvertedBack = Vector3.zero;
             HalfVector3 = new HalfVector3(vector3, axisToSynchronize);
+            SynchronizeBase = false;
+            CollapsedDeltaIntoBase = false;
             UpdateFrom(ref vector3, networkTick);
         }
 

com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs

@@ -532,6 +532,23 @@ internal void InternalOnGainedOwnership()
             OnGainedOwnership();
         }
 
+        /// <summary>
+        /// Invoked on all clients, override this method to be notified of any
+        /// ownership changes (even if the instance was niether the previous or
+        /// newly assigned current owner). 
+        /// </summary>
+        /// <param name="previous">the previous owner</param>
+        /// <param name="current">the current owner</param>
+        protected virtual void OnOwnershipChanged(ulong previous, ulong current)
+        {
+
+        }
+
+        internal void InternalOnOwnershipChanged(ulong previous, ulong current)
+        {
+            OnOwnershipChanged(previous, current);
+        }
+
         /// <summary>
         /// Gets called when we loose ownership of this object
         /// </summary>

com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs

@@ -753,6 +753,21 @@ internal void InvokeBehaviourOnGainedOwnership()
             }
         }
 
+        internal void InvokeOwnershipChanged(ulong previous, ulong next)
+        {
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].InternalOnOwnershipChanged(previous, next);
+                }
+                else
+                {
+                    Debug.LogWarning($"{ChildNetworkBehaviours[i].gameObject.name} is disabled! Netcode for GameObjects does not support disabled NetworkBehaviours! The {ChildNetworkBehaviours[i].GetType().Name} component was skipped during ownership assignment!");
+                }
+            }
+        }
+
         internal void InvokeBehaviourOnNetworkObjectParentChanged(NetworkObject parentNetworkObject)
         {
             for (int i = 0; i < ChildNetworkBehaviours.Count; i++)

com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -60,6 +60,8 @@ public void Handle(ref NetworkContext context)
                 }
             }
 
+            networkObject.InvokeOwnershipChanged(originalOwner, OwnerClientId);
+
             networkManager.NetworkMetrics.TrackOwnershipChangeReceived(context.SenderId, networkObject, context.MessageSize);
         }
     }

com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs

@@ -257,6 +257,7 @@ internal void ChangeOwnership(NetworkObject networkObject, ulong clientId)
                 throw new SpawnStateException("Object is not spawned");
             }
 
+            var previous = networkObject.OwnerClientId;
             // Assign the new owner
             networkObject.OwnerClientId = clientId;
 
@@ -286,6 +287,12 @@ internal void ChangeOwnership(NetworkObject networkObject, ulong clientId)
                     NetworkManager.NetworkMetrics.TrackOwnershipChangeSent(client.Key, networkObject, size);
                 }
             }
+
+            // After we have sent the change ownership message to all client observers, invoke the ownership changed notification.
+            /// !!Important!!
+            /// This gets called specifically *after* sending the ownership message so any additional messages that need to proceed an ownership
+            /// change can be sent from NetworkBehaviours that override the <see cref="NetworkBehaviour.OnOwnershipChanged"></see>
+            networkObject.InvokeOwnershipChanged(previous, clientId);
         }
 
         internal bool HasPrefab(NetworkObject.SceneObject sceneObject)

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

@@ -230,6 +230,11 @@ public void TestSyncAxes([Values] SynchronizationType synchronizationType, [Valu
             var gameObject = new GameObject($"Test-{nameof(NetworkTransformStateTests)}.{nameof(TestSyncAxes)}");
             var networkObject = gameObject.AddComponent<NetworkObject>();
             var networkTransform = gameObject.AddComponent<NetworkTransform>();
+
+            var manager = new GameObject($"Test-{nameof(NetworkManager)}.{nameof(TestSyncAxes)}");
+            var networkManager = manager.AddComponent<NetworkManager>();
+            networkObject.NetworkManagerOwner = networkManager;
+
             networkTransform.enabled = false; // do not tick `FixedUpdate()` or `Update()`
 
             var initialPosition = Vector3.zero;
@@ -269,6 +274,7 @@ public void TestSyncAxes([Values] SynchronizationType synchronizationType, [Valu
 
                 if (syncPosX || syncPosY || syncPosZ || syncRotX || syncRotY || syncRotZ || syncScaX || syncScaY || syncScaZ)
                 {
+                    Assert.IsTrue(networkTransform.NetworkManager != null, "NetworkManager is NULL!");
                     Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
                 }
             }
@@ -714,6 +720,7 @@ public void TestSyncAxes([Values] SynchronizationType synchronizationType, [Valu
             }
 
             Object.DestroyImmediate(gameObject);
+            Object.DestroyImmediate(manager);
         }
 
 

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

@@ -470,7 +470,7 @@ private void AllChildrenLocalTransformValuesMatch(bool useSubChild)
                     var childLocalRotation = childInstance.transform.localRotation.eulerAngles;
                     var childLocalScale = childInstance.transform.localScale;
                     // Adjust approximation based on precision
-                    if (m_Precision == Precision.Half)
+                    if (m_Precision == Precision.Half || m_RotationCompression == RotationCompression.QuaternionCompress)
                     {
                         m_CurrentHalfPrecision = k_HalfPrecisionPosScale;
                     }
@@ -486,7 +486,7 @@ private void AllChildrenLocalTransformValuesMatch(bool useSubChild)
                     }
 
                     // Adjust approximation based on precision
-                    if (m_Precision == Precision.Half)
+                    if (m_Precision == Precision.Half || m_RotationCompression == RotationCompression.QuaternionCompress)
                     {
                         m_CurrentHalfPrecision = k_HalfPrecisionRot;
                     }
@@ -523,6 +523,7 @@ public void ParentedNetworkTransformTest([Values] Precision precision, [Values]
         {
             // Set the precision being used for threshold adjustments
             m_Precision = precision;
+            m_RotationCompression = rotationCompression;
 
             // Get the NetworkManager that will have authority in order to spawn with the correct authority
             var isServerAuthority = m_Authority == Authority.ServerAuthority;
@@ -577,6 +578,9 @@ public void ParentedNetworkTransformTest([Values] Precision precision, [Values]
 
             // Allow one tick for authority to update these changes
             TimeTravelToNextTick();
+            success = WaitForConditionOrTimeOutWithTimeTravel(PositionRotationScaleMatches);
+
+            Assert.True(success, "All transform values did not match prior to parenting!");
 
             // Parent the child under the parent with the current world position stays setting
             Assert.True(serverSideChild.TrySetParent(serverSideParent.transform, worldPositionStays), "[Server-Side Child] Failed to set child's parent!");
@@ -588,6 +592,7 @@ public void ParentedNetworkTransformTest([Values] Precision precision, [Values]
             success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesHaveChild);
             Assert.True(success, "Timed out waiting for all instances to have parented a child!");
 
+            TimeTravelToNextTick();
             // This validates each child instance has preserved their local space values
             AllChildrenLocalTransformValuesMatch(false);
 
@@ -688,8 +693,9 @@ protected override void OnNewClientCreated(NetworkManager networkManager)
         }
 
         private Precision m_Precision = Precision.Full;
+        private RotationCompression m_RotationCompression = RotationCompression.None;
         private float m_CurrentHalfPrecision = 0.0f;
-        private const float k_HalfPrecisionPosScale = 0.03f;
+        private const float k_HalfPrecisionPosScale = 0.041f;
         private const float k_HalfPrecisionRot = 0.725f;
 
         protected override float GetDeltaVarianceThreshold()