fix: Parenting does not preserve WorldPositionStays option and other parenting related issues (#2146)

* fix
Parenting:
Fixed the issue where WorldPositionStays was not being synchronized with clients.
Removed m_IsReparented and associated properties.
Added world position stays parameter to CreateLocalNetworkObject to preserve worldPostionStays.
This fixes some edge case scenarios and issues with parenting in-scene placed NetworkObjects.
One in particular is to provide the local space position and rotation in ParentSyncMessage if the WorldPositionStays value is false.  The server might maintain the original local space values and upon being reparented it re-applies the local space values.  This is only pertinent if the user decides they don't want to use a NetworkTransform for the NetworkObject in question.
Now, a users can control what the final position, rotation, and scale of a NetworkObject is when being added/removed to/from a parent's sibling list ("parented or de-parented").
Parenting and Scale:
Fixed issue where GetMessageSceneObject wasn't using the NetworkObject's lossy scale value.  This would result in improper scaling of parented (WorldPositionStays = true) child NetworkObjects for late joining clients.  Added comments with details on this.
Fixed edge case scenario where nested in-scene placed NetworkObject children are de-parented and then a client late joins. Under this scenario (only for in-scene placed NetworkObjects) we want the late joining client to remove its parent, then set the transform values, and then get spawned.

NetworkTransform:
Fixed issue where TryCommitTransformToServer was not honoring the NetworkTransform.InLocalSpace property.
Fixed issue where teleporting did not honor the NetworkTransforms's current synchronize axis settings.
Removed the private m_TickFrequency property as it is no longer being used.

* refactor
CreateLocalNetworkObject now just accepts the NetworkObject.SceneObject structure as opposed to the 10 properties of the NetworkObject.SceneObject structure passed in as parameters.
Provided the ability to invoke NetworkObject.TrySetParent with a null value in order to be able to remove a parent while also selecting whether they want WorldPositionStay to be true or false (when removing a parent WorldPositionStays impacts the final transform values and can lead to scale issue if you parent with WorldPositionStays set to false and then it remove the parent with WorldPositionStays set to true).
Consolidated the CreateLocalNetworkObject's assignment of the transform values, parenting, and DDOL migration.
Removed parenting from CreateLocalNetworkObject
Removed setting the cached parent directly within SpawnNetworkObjectLocallyCommon as this is done within NetworkObject.ApplyNetworkParenting.

* add
Added RemoveParent to the ParentSync message.
Added applying scale to CreateLocalNetworkObject.
Added parent child sorting to the SceneEventData's synchronization serialization process.
Added the TryRemoveParent helper method to make removing a parent easier.  Without this method users will have to use TrySetParent and cast the null value to either GameObject or NetworkObject.

* test
Added ParentingWorldPositionStaysTest:
Testing with and without WorldPositionStays while also varying child position, rotation, and scale values.
Validates scale with multi-generation nested children where most of the parents have a scale other than Vector3.one. 
Created abstract IntegrationTestWithApproximation to avoid replicating the exact same set of Approximately methods.

Added ParentingInSceneObjectsTests:
This includes all of the scripts and assets that the ParentingInSceneObjectsTests needs.
It includes adding the ParentingInSceneObjects scene to the scenes in build list as well.
This also verifies an in-scene placed NetworkObject parented under a GameObject will preserve that hierarchy.

NetworkTransformStateTest:
Updated the bool parameters to be more meaningful named enums so you know what exactly is being tested.
Added additional NetworkTansformState.IsTeleportingNextFrame logic to the existing test.
Added an additional "step" which verifies the NetworkTransformState is additively collapsing for each detected axial delta over the relative threshold value.

Co-authored-by: Jesse Olmer <[email protected]>
Co-authored-by: Unity Netcode CI <[email protected]>

Author: 3 people

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -13,6 +13,8 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 - IPv6 is now supported for direct connections when using `UnityTransport`. (#2232)
 - Added WebSocket support when using UTP 2.0 with `UseWebSockets` property in the `UnityTransport` component of the `NetworkManager` allowing to pick WebSockets for communication. When building for WebGL, this selection happens automatically. (#2201)
+- Added position, rotation, and scale to the `ParentSyncMessage` which provides users the ability to specify the final values on the server-side when `OnNetworkObjectParentChanged` is invoked just before the message is created (when the `Transform` values are applied to the message). (#2146)
+- Added `NetworkObject.TryRemoveParent` method for convenience purposes opposed to having to cast null to either `GameObject` or `NetworkObject`. (#2146)
 
 ### Changed
 
@@ -33,6 +35,11 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Implicit conversion of NetworkObjectReference to GameObject will now return null instead of throwing an exception if the referenced object could not be found (i.e., was already despawned) (#2158)
 - Fixed warning resulting from a stray NetworkAnimator.meta file (#2153)
 - Fixed Connection Approval Timeout not working client side. (#2164)
+- Fixed issue where the `WorldPositionStays` parenting parameter was not being synchronized with clients. (#2146)
+- Fixed issue where parented in-scene placed `NetworkObject`s would fail for late joining clients. (#2146)
+- Fixed issue where scale was not being synchronized which caused issues with nested parenting and scale when `WorldPositionStays` was true. (#2146)
+- Fixed issue with `NetworkTransform.ApplyTransformToNetworkStateWithInfo` where it was not honoring axis sync settings when `NetworkTransformState.IsTeleportingNextFrame` was true. (#2146)
+- Fixed issue with `NetworkTransform.TryCommitTransformToServer` where it was not honoring the `InLocalSpace` setting. (#2146)
 - Fixed ClientRpcs always reporting in the profiler view as going to all clients, even when limited to a subset of clients by `ClientRpcParams`. (#2144)
 - Fixed RPC codegen failing to choose the correct extension methods for `FastBufferReader` and `FastBufferWriter` when the parameters were a generic type (i.e., List<int>) and extensions for multiple instantiations of that type have been defined (i.e., List<int> and List<string>) (#2142)
 - Fixed the issue where running a server (i.e. not host) the second player would not receive updates (unless a third player joined). (#2127)

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

@@ -451,19 +451,6 @@ internal NetworkTransformState GetLastSentState()
             return m_LastSentState;
         }
 
-        /// <summary>
-        /// Calculated when spawned, this is used to offset a newly received non-authority side state by 1 tick duration
-        /// in order to end the extrapolation for that state's values.
-        /// </summary>
-        /// <remarks>
-        /// Example:
-        /// NetworkState-A is received, processed, and measurements added
-        /// NetworkState-A is duplicated (NetworkState-A-Post) and its sent time is offset by the tick frequency
-        /// One tick later, NetworkState-A-Post is applied to end that delta's extrapolation.
-        /// <see cref="OnNetworkStateChanged"/> to see how NetworkState-A-Post doesn't get excluded/missed
-        /// </remarks>
-        private double m_TickFrequency;
-
         /// <summary>
         /// This will try to send/commit the current transform delta states (if any)
         /// </summary>
@@ -488,14 +475,16 @@ protected void TryCommitTransformToServer(Transform transformToCommit, double di
             }
             else // Non-Authority
             {
+                var position = InLocalSpace ? transformToCommit.localPosition : transformToCommit.position;
+                var rotation = InLocalSpace ? transformToCommit.localRotation : transformToCommit.rotation;
                 // We are an owner requesting to update our state
                 if (!m_CachedIsServer)
                 {
-                    SetStateServerRpc(transformToCommit.position, transformToCommit.rotation, transformToCommit.localScale, false);
+                    SetStateServerRpc(position, rotation, transformToCommit.localScale, false);
                 }
                 else // Server is always authoritative (including owner authoritative)
                 {
-                    SetStateClientRpc(transformToCommit.position, transformToCommit.rotation, transformToCommit.localScale, false);
+                    SetStateClientRpc(position, rotation, transformToCommit.localScale, false);
                 }
             }
         }
@@ -521,37 +510,24 @@ private void TryCommitTransform(Transform transformToCommit, double dirtyTime)
             }
         }
 
+        /// <summary>
+        /// Initializes the interpolators with the current transform values
+        /// </summary>
         private void ResetInterpolatedStateToCurrentAuthoritativeState()
         {
             var serverTime = NetworkManager.ServerTime.Time;
-
-            // TODO: Look into a better way to communicate the entire state for late joining clients.
-            // Since the replicated network state will just be the most recent deltas and not the entire state.
-            //m_PositionXInterpolator.ResetTo(m_LocalAuthoritativeNetworkState.PositionX, serverTime);
-            //m_PositionYInterpolator.ResetTo(m_LocalAuthoritativeNetworkState.PositionY, serverTime);
-            //m_PositionZInterpolator.ResetTo(m_LocalAuthoritativeNetworkState.PositionZ, serverTime);
-
-            //m_RotationInterpolator.ResetTo(Quaternion.Euler(m_LocalAuthoritativeNetworkState.RotAngleX, m_LocalAuthoritativeNetworkState.RotAngleY, m_LocalAuthoritativeNetworkState.RotAngleZ), serverTime);
-
-            //m_ScaleXInterpolator.ResetTo(m_LocalAuthoritativeNetworkState.ScaleX, serverTime);
-            //m_ScaleYInterpolator.ResetTo(m_LocalAuthoritativeNetworkState.ScaleY, serverTime);
-            //m_ScaleZInterpolator.ResetTo(m_LocalAuthoritativeNetworkState.ScaleZ, serverTime);
-
-            // NOTE ABOUT THIS CHANGE:
-            // !!! This will exclude any scale changes because we currently do not spawn network objects with scale !!!
-            // Regarding Scale: It will be the same scale as the default scale for the object being spawned.
             var position = InLocalSpace ? transform.localPosition : transform.position;
             m_PositionXInterpolator.ResetTo(position.x, serverTime);
             m_PositionYInterpolator.ResetTo(position.y, serverTime);
             m_PositionZInterpolator.ResetTo(position.z, serverTime);
+
             var rotation = InLocalSpace ? transform.localRotation : transform.rotation;
             m_RotationInterpolator.ResetTo(rotation, serverTime);
 
-            // TODO: (Create Jira Ticket) Synchronize local scale during NetworkObject synchronization
-            // (We will probably want to byte pack TransformData to offset the 3 float addition)
-            m_ScaleXInterpolator.ResetTo(transform.localScale.x, serverTime);
-            m_ScaleYInterpolator.ResetTo(transform.localScale.y, serverTime);
-            m_ScaleZInterpolator.ResetTo(transform.localScale.z, serverTime);
+            var scale = transform.localScale;
+            m_ScaleXInterpolator.ResetTo(scale.x, serverTime);
+            m_ScaleYInterpolator.ResetTo(scale.y, serverTime);
+            m_ScaleZInterpolator.ResetTo(scale.z, serverTime);
         }
 
         /// <summary>
@@ -602,63 +578,63 @@ private bool ApplyTransformToNetworkStateWithInfo(ref NetworkTransformState netw
                 isDirty = true;
             }
 
-            if (SyncPositionX && Mathf.Abs(networkState.PositionX - position.x) >= PositionThreshold || networkState.IsTeleportingNextFrame)
+            if (SyncPositionX && (Mathf.Abs(networkState.PositionX - position.x) >= PositionThreshold || networkState.IsTeleportingNextFrame))
             {
                 networkState.PositionX = position.x;
                 networkState.HasPositionX = true;
                 isPositionDirty = true;
             }
 
-            if (SyncPositionY && Mathf.Abs(networkState.PositionY - position.y) >= PositionThreshold || networkState.IsTeleportingNextFrame)
+            if (SyncPositionY && (Mathf.Abs(networkState.PositionY - position.y) >= PositionThreshold || networkState.IsTeleportingNextFrame))
             {
                 networkState.PositionY = position.y;
                 networkState.HasPositionY = true;
                 isPositionDirty = true;
             }
 
-            if (SyncPositionZ && Mathf.Abs(networkState.PositionZ - position.z) >= PositionThreshold || networkState.IsTeleportingNextFrame)
+            if (SyncPositionZ && (Mathf.Abs(networkState.PositionZ - position.z) >= PositionThreshold || networkState.IsTeleportingNextFrame))
             {
                 networkState.PositionZ = position.z;
                 networkState.HasPositionZ = true;
                 isPositionDirty = true;
             }
 
-            if (SyncRotAngleX && Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleX, rotAngles.x)) >= RotAngleThreshold || networkState.IsTeleportingNextFrame)
+            if (SyncRotAngleX && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleX, rotAngles.x)) >= RotAngleThreshold || networkState.IsTeleportingNextFrame))
             {
                 networkState.RotAngleX = rotAngles.x;
                 networkState.HasRotAngleX = true;
                 isRotationDirty = true;
             }
 
-            if (SyncRotAngleY && Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleY, rotAngles.y)) >= RotAngleThreshold || networkState.IsTeleportingNextFrame)
+            if (SyncRotAngleY && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleY, rotAngles.y)) >= RotAngleThreshold || networkState.IsTeleportingNextFrame))
             {
                 networkState.RotAngleY = rotAngles.y;
                 networkState.HasRotAngleY = true;
                 isRotationDirty = true;
             }
 
-            if (SyncRotAngleZ && Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleZ, rotAngles.z)) >= RotAngleThreshold || networkState.IsTeleportingNextFrame)
+            if (SyncRotAngleZ && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleZ, rotAngles.z)) >= RotAngleThreshold || networkState.IsTeleportingNextFrame))
             {
                 networkState.RotAngleZ = rotAngles.z;
                 networkState.HasRotAngleZ = true;
                 isRotationDirty = true;
             }
 
-            if (SyncScaleX && Mathf.Abs(networkState.ScaleX - scale.x) >= ScaleThreshold || networkState.IsTeleportingNextFrame)
+            if (SyncScaleX && (Mathf.Abs(networkState.ScaleX - scale.x) >= ScaleThreshold || networkState.IsTeleportingNextFrame))
             {
                 networkState.ScaleX = scale.x;
                 networkState.HasScaleX = true;
                 isScaleDirty = true;
             }
 
-            if (SyncScaleY && Mathf.Abs(networkState.ScaleY - scale.y) >= ScaleThreshold || networkState.IsTeleportingNextFrame)
+            if (SyncScaleY && (Mathf.Abs(networkState.ScaleY - scale.y) >= ScaleThreshold || networkState.IsTeleportingNextFrame))
             {
                 networkState.ScaleY = scale.y;
                 networkState.HasScaleY = true;
                 isScaleDirty = true;
             }
 
-            if (SyncScaleZ && Mathf.Abs(networkState.ScaleZ - scale.z) >= ScaleThreshold || networkState.IsTeleportingNextFrame)
+            if (SyncScaleZ && (Mathf.Abs(networkState.ScaleZ - scale.z) >= ScaleThreshold || networkState.IsTeleportingNextFrame))
             {
                 networkState.ScaleZ = scale.z;
                 networkState.HasScaleZ = true;
@@ -1007,7 +983,6 @@ public override void OnNetworkSpawn()
         {
             m_CachedIsServer = IsServer;
             m_CachedNetworkManager = NetworkManager;
-            m_TickFrequency = 1.0 / NetworkManager.NetworkConfig.TickRate;
 
             Initialize();
 

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

@@ -2070,14 +2070,31 @@ internal void HandleConnectionApproval(ulong ownerClientId, ConnectionApprovalRe
 
                 if (response.CreatePlayerObject)
                 {
-                    var networkObject = SpawnManager.CreateLocalNetworkObject(
-                        isSceneObject: false,
-                        response.PlayerPrefabHash ?? NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash,
-                        ownerClientId,
-                        parentNetworkId: null,
-                        networkSceneHandle: null,
-                        response.Position,
-                        response.Rotation);
+                    var playerPrefabHash = response.PlayerPrefabHash ?? NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
+
+                    // Generate a SceneObject for the player object to spawn
+                    var sceneObject = new NetworkObject.SceneObject
+                    {
+                        Header = new NetworkObject.SceneObject.HeaderData
+                        {
+                            IsPlayerObject = true,
+                            OwnerClientId = ownerClientId,
+                            IsSceneObject = false,
+                            HasTransform = true,
+                            Hash = playerPrefabHash,
+                        },
+                        TargetClientId = ownerClientId,
+                        Transform = new NetworkObject.SceneObject.TransformData
+                        {
+                            Position = response.Position.GetValueOrDefault(),
+                            Rotation = response.Rotation.GetValueOrDefault()
+                        }
+                    };
+
+                    // Create the player NetworkObject locally
+                    var networkObject = SpawnManager.CreateLocalNetworkObject(sceneObject);
+
+                    // Spawn the player NetworkObject locally
                     SpawnManager.SpawnNetworkObjectLocally(
                         networkObject,
                         SpawnManager.GetNetworkObjectId(),