fix: NetworkObjects do not honor when Auto Object Parent Sync is turned off (#2281)

* fix
This resolves the issue where NetworkObjects were not taking Auto Object Parent Sync into consideration.

* test
The test to validate that nested in-scene placed NetworkObjects that both have Auto Object Parent Synchronization enabled and disabled synchronize their transforms properly on the client side. The same test covers NetworkObjects nested under GameObjects with no NetworkObject components.  All nested instances have varying position, rotation, and scale values.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -11,6 +11,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Fixed
 
+- Fixed issue where in-scene placed `NetworkObjects` were not honoring the `AutoObjectParentSync` property. (#2281)
 - Fixed the issue where `NetworkManager.OnClientConnectedCallback` was being invoked before in-scene placed `NetworkObject`s had been spawned when starting `NetworkManager` as a host. (#2277)
 - Creating a `FastBufferReader` with `Allocator.None` will not result in extra memory being allocated for the buffer (since it's owned externally in that scenario). (#2265)
 

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

@@ -830,6 +830,9 @@ internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpa
                 // parent and then re-parents the child under a GameObject with a NetworkObject component attached.
                 if (parentNetworkObject == null)
                 {
+                    // If we are parented under a GameObject, go ahead and mark the world position stays as false
+                    // so clients synchronize their transform in local space. (only for in-scene placed NetworkObjects)
+                    m_CachedWorldPositionStays = false;
                     return true;
                 }
                 else // If the parent still isn't spawned add this to the orphaned children and return false
@@ -841,8 +844,11 @@ internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpa
                 else
                 {
                     // If we made it this far, go ahead and set the network parenting values
-                    // with the default WorldPoisitonSays value
-                    SetNetworkParenting(parentNetworkObject.NetworkObjectId, true);
+                    // with the WorldPoisitonSays value set to false
+                    // Note: Since in-scene placed NetworkObjects are parented in the scene
+                    // the default "assumption" is that children are parenting local space
+                    // relative.
+                    SetNetworkParenting(parentNetworkObject.NetworkObjectId, false);
 
                     // Set the cached parent
                     m_CachedParent = parentNetworkObject.transform;
@@ -1235,6 +1241,13 @@ internal SceneObject GetMessageSceneObject(ulong targetClientId)
             if (!AlwaysReplicateAsRoot && transform.parent != null)
             {
                 parentNetworkObject = transform.parent.GetComponent<NetworkObject>();
+                // In-scene placed NetworkObjects parented under GameObjects with no NetworkObject
+                // should set the has parent flag and preserve the world position stays value
+                if (parentNetworkObject == null && obj.Header.IsSceneObject)
+                {
+                    obj.Header.HasParent = true;
+                    obj.WorldPositionStays = m_CachedWorldPositionStays;
+                }
             }
 
             if (parentNetworkObject != null)
@@ -1254,19 +1267,37 @@ internal SceneObject GetMessageSceneObject(ulong targetClientId)
             if (IncludeTransformWhenSpawning == null || IncludeTransformWhenSpawning(OwnerClientId))
             {
                 obj.Header.HasTransform = true;
+
+                // We start with the default AutoObjectParentSync values to determine which transform space we will
+                // be synchronizing clients with.
+                var syncRotationPositionLocalSpaceRelative = obj.Header.HasParent && !m_CachedWorldPositionStays;
+                var syncScaleLocalSpaceRelative = obj.Header.HasParent && !m_CachedWorldPositionStays;
+
+                // If auto object synchronization is turned off
+                if (!AutoObjectParentSync)
+                {
+                    // We always synchronize position and rotation world space relative
+                    syncRotationPositionLocalSpaceRelative = false;
+                    // Scale is special, it synchronizes local space relative if it has a
+                    // parent since applying the world space scale under a parent with scale
+                    // will result in the improper scale for the child
+                    syncScaleLocalSpaceRelative = obj.Header.HasParent;
+                }
+
+
                 obj.Transform = new SceneObject.TransformData
                 {
                     // If we are parented and we have the m_CachedWorldPositionStays disabled, then use local space
                     // values as opposed world space values.
-                    Position = parentNetworkObject && !m_CachedWorldPositionStays ? transform.localPosition : transform.position,
-                    Rotation = parentNetworkObject && !m_CachedWorldPositionStays ? transform.localRotation : transform.rotation,
+                    Position = syncRotationPositionLocalSpaceRelative ? transform.localPosition : transform.position,
+                    Rotation = syncRotationPositionLocalSpaceRelative ? transform.localRotation : transform.rotation,
 
                     // We only use the lossyScale if the NetworkObject has a parent. Multi-generation nested children scales can
                     // impact the final scale of the child NetworkObject in question. The solution is to use the lossy scale
                     // which can be thought of as "world space scale".
                     // More information:
                     // https://docs.unity3d.com/ScriptReference/Transform-lossyScale.html
-                    Scale = parentNetworkObject && !m_CachedWorldPositionStays ? transform.localScale : transform.lossyScale,
+                    Scale = syncScaleLocalSpaceRelative ? transform.localScale : transform.lossyScale,
                 };
             }
 

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

@@ -402,7 +402,7 @@ internal NetworkObject CreateLocalNetworkObject(NetworkObject.SceneObject sceneO
 
             if (networkObject != null)
             {
-                // SPECIAL CASE:
+                // SPECIAL CASE FOR IN-SCENE PLACED:  (only when the parent has a NetworkObject)
                 // This is a special case scenario where a late joining client has joined and loaded one or
                 // more scenes that contain nested in-scene placed NetworkObject children yet the server's
                 // synchronization information does not indicate the NetworkObject in question has a parent.
@@ -423,7 +423,9 @@ internal NetworkObject CreateLocalNetworkObject(NetworkObject.SceneObject sceneO
                 // but it is up to the user to set those values
                 if (sceneObject.Header.HasTransform && !isSpawnedByPrefabHandler)
                 {
-                    if (worldPositionStays)
+                    // If world position stays is true or we have auto object parent synchronization disabled
+                    // then we want to apply the position and rotation values world space relative
+                    if (worldPositionStays || !networkObject.AutoObjectParentSync)
                     {
                         networkObject.transform.position = position;
                         networkObject.transform.rotation = rotation;
@@ -443,6 +445,9 @@ internal NetworkObject CreateLocalNetworkObject(NetworkObject.SceneObject sceneO
                     // that is the default value of Vector3.
                     if (!sceneObject.Header.IsPlayerObject)
                     {
+                        // Since scale is always applied to local space scale, we do the transform
+                        // space logic during serialization such that it works out whether AutoObjectParentSync
+                        // is enabled or not (see NetworkObject.SceneObject)
                         networkObject.transform.localScale = scale;
                     }
                 }

testproject/Assets/Tests/Runtime/ObjectParenting/ParentingAutoSyncManager.cs

@@ -0,0 +1,64 @@
+using System.Collections.Generic;
+using UnityEngine;
+using Unity.Netcode;
+
+
+namespace TestProject.RuntimeTests
+{
+    /// <summary>
+    /// Helper class that builds 4 transform lists based on parent-child hierarchy
+    /// for the <see cref="ParentingInSceneObjectsTests.InSceneNestedAutoSyncObjectTest"/>
+    /// </summary>
+    public class ParentingAutoSyncManager : NetworkBehaviour
+    {
+        public static ParentingAutoSyncManager ServerInstance;
+        public static Dictionary<ulong, ParentingAutoSyncManager> ClientInstances = new Dictionary<ulong, ParentingAutoSyncManager>();
+
+        public GameObject WithNetworkObjectAutoSyncOn;
+        public GameObject WithNetworkObjectAutoSyncOff;
+        public GameObject GameObjectAutoSyncOn;
+        public GameObject GameObjectAutoSyncOff;
+
+        public List<Transform> NetworkObjectAutoSyncOnTransforms = new List<Transform>();
+        public List<Transform> NetworkObjectAutoSyncOffTransforms = new List<Transform>();
+        public List<Transform> GameObjectAutoSyncOnTransforms = new List<Transform>();
+        public List<Transform> GameObjectAutoSyncOffTransforms = new List<Transform>();
+
+        public static void Reset()
+        {
+            ServerInstance = null;
+            ClientInstances.Clear();
+        }
+
+        public override void OnNetworkSpawn()
+        {
+            if (IsServer)
+            {
+                ServerInstance = this;
+            }
+            else
+            {
+                ClientInstances.Add(NetworkManager.LocalClientId, this);
+            }
+            var currentRoot = WithNetworkObjectAutoSyncOn.transform;
+            NetworkObjectAutoSyncOnTransforms.Add(currentRoot);
+            NetworkObjectAutoSyncOnTransforms.Add(currentRoot.GetChild(0));
+            NetworkObjectAutoSyncOnTransforms.Add(currentRoot.GetChild(0).GetChild(0));
+
+            currentRoot = WithNetworkObjectAutoSyncOff.transform;
+            NetworkObjectAutoSyncOffTransforms.Add(currentRoot);
+            NetworkObjectAutoSyncOffTransforms.Add(currentRoot.GetChild(0));
+            NetworkObjectAutoSyncOffTransforms.Add(currentRoot.GetChild(0).GetChild(0));
+
+            currentRoot = GameObjectAutoSyncOn.transform;
+            GameObjectAutoSyncOnTransforms.Add(currentRoot);
+            GameObjectAutoSyncOnTransforms.Add(currentRoot.GetChild(0));
+            GameObjectAutoSyncOnTransforms.Add(currentRoot.GetChild(0).GetChild(0));
+
+            currentRoot = GameObjectAutoSyncOff.transform;
+            GameObjectAutoSyncOffTransforms.Add(currentRoot);
+            GameObjectAutoSyncOffTransforms.Add(currentRoot.GetChild(0));
+            GameObjectAutoSyncOffTransforms.Add(currentRoot.GetChild(0).GetChild(0));
+        }
+    }
+}