Merge branch 'develop' into experimental/ngo-and-n4e

Author: NoelStephensUnity

.github/CODEOWNERS

@@ -7,10 +7,10 @@ Metrics/ @Unity-Technologies/multiplayer-tools
 /com.unity.netcode.gameobjects/Runtime/Transports/ @Unity-Technologies/multiplayer-server
 /com.unity.netcode.gameobjects/Tests/Editor/Transports/ @Unity-Technologies/multiplayer-server
 /com.unity.netcode.gameobjects/Tests/Runtime/Transports/ @Unity-Technologies/multiplayer-server
-*.asmdef @ThusSpokeNomad
-package.json @ThusSpokeNomad
-AssemblyInfo.cs @ThusSpokeNomad
-.editorconfig @ThusSpokeNomad
-.gitignore @ThusSpokeNomad
-.github/ @ThusSpokeNomad @lpmaurice @ashwinimurt
-.yamato/ @ThusSpokeNomad @lpmaurice @ashwinimurt
+*.asmdef @chrispope @tylerunity
+package.json @chrispope @tylerunity
+AssemblyInfo.cs @chrispope @tylerunity
+.editorconfig @chrispope @tylerunity
+.gitignore @chrispope @tylerunity
+.github/ @chrispope @tylerunity
+.yamato/ @chrispope @tylerunity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -10,11 +10,16 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Added
 
+- Added `NetworkObject.SpawnWithObservers` property (default is true) that when set to false will spawn a `NetworkObject` with no observers and will not be spawned on any client until `NetworkObject.NetworkShow` is invoked. (#2568)
+
 ### Fixed
 
+- Fixed warning "Runtime Network Prefabs was not empty at initialization time." being erroneously logged when no runtime network prefabs had been added (#2565)
 - Fixed issue where some temporary debug console logging was left in a merged PR. (#2562)
 - Fixed the "Generate Default Network Prefabs List" setting not loading correctly and always reverting to being checked. (#2545)
+- Fixed issue where users could not use NetworkSceneManager.VerifySceneBeforeLoading to exclude runtime generated scenes from client synchronization. (#2550)
 - Fixed missing value on `NetworkListEvent` for `EventType.RemoveAt` events.  (#2542,#2543)
+- Fixed issue where parenting a NetworkTransform under a transform with a scale other than Vector3.one would result in incorrect values on non-authoritative instances. (#2538)
 - Fixed issue where a server would include scene migrated and then despawned NetworkObjects to a client that was being synchronized. (#2532)
 - Fixed the inspector throwing exceptions when attempting to render `NetworkVariable`s of enum types. (#2529)
 - Making a `NetworkVariable` with an `INetworkSerializable` type that doesn't meet the `new()` constraint will now create a compile-time error instead of an editor crash (#2528)
@@ -27,6 +32,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ## Changed
 
+- Adding network prefabs before NetworkManager initialization is now supported. (#2565)
 - Connecting clients being synchronized now switch to the server's active scene before spawning and synchronizing NetworkObjects. (#2532)
 - Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.4. (#2533)
 - Improved performance of NetworkBehaviour initialization by replacing reflection when initializing NetworkVariables with compile-time code generation, which should help reduce hitching during additive scene loads. (#2522)

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

@@ -2392,16 +2392,6 @@ public override void OnNetworkSpawn()
             m_CachedNetworkManager = NetworkManager;
 
             Initialize();
-            // This assures the initial spawning of the object synchronizes all connected clients
-            // with the current transform values. This should not be placed within Initialize since
-            // that can be invoked when ownership changes.
-            if (CanCommitToTransform)
-            {
-                var currentPosition = GetSpaceRelativePosition();
-                var currentRotation = GetSpaceRelativeRotation();
-                // Teleport to current position
-                SetStateInternal(currentPosition, currentRotation, transform.localScale, true);
-            }
         }
 
         /// <inheritdoc/>
@@ -2472,6 +2462,7 @@ protected void Initialize()
             CanCommitToTransform = IsServerAuthoritative() ? IsServer : IsOwner;
             var replicatedState = ReplicatedNetworkState;
             var currentPosition = GetSpaceRelativePosition();
+            var currentRotation = GetSpaceRelativeRotation();
 
             if (CanCommitToTransform)
             {
@@ -2483,6 +2474,9 @@ protected void Initialize()
                 // Authority only updates once per network tick
                 NetworkManager.NetworkTickSystem.Tick -= NetworkTickSystem_Tick;
                 NetworkManager.NetworkTickSystem.Tick += NetworkTickSystem_Tick;
+
+                // Teleport to current position
+                SetStateInternal(currentPosition, currentRotation, transform.localScale, true);
             }
             else
             {
@@ -2494,15 +2488,42 @@ protected void Initialize()
                 NetworkManager.NetworkTickSystem.Tick -= NetworkTickSystem_Tick;
 
                 ResetInterpolatedStateToCurrentAuthoritativeState();
-                m_CurrentPosition = GetSpaceRelativePosition();
+                m_CurrentPosition = currentPosition;
                 m_CurrentScale = transform.localScale;
-                m_CurrentRotation = GetSpaceRelativeRotation();
+                m_CurrentRotation = currentRotation;
 
             }
 
             OnInitialize(ref replicatedState);
         }
 
+        /// <inheritdoc/>
+        /// <remarks>
+        /// When a parent changes, non-authoritative instances should:
+        /// - Apply the resultant position, rotation, and scale from the parenting action.
+        /// - Clear interpolators (even if not enabled on this frame)
+        /// - Reset the interpolators to the position, rotation, and scale resultant values.
+        /// This prevents interpolation visual anomalies and issues during initial synchronization
+        /// </remarks>
+        public override void OnNetworkObjectParentChanged(NetworkObject parentNetworkObject)
+        {
+            // Only if we are not authority
+            if (!CanCommitToTransform)
+            {
+                m_CurrentPosition = GetSpaceRelativePosition();
+                m_CurrentRotation = GetSpaceRelativeRotation();
+                m_CurrentScale = GetScale();
+                m_ScaleInterpolator.Clear();
+                m_PositionInterpolator.Clear();
+                m_RotationInterpolator.Clear();
+                var tempTime = new NetworkTime(NetworkManager.NetworkConfig.TickRate, NetworkManager.ServerTime.Tick).Time;
+                UpdatePositionInterpolator(m_CurrentPosition, tempTime, true);
+                m_ScaleInterpolator.ResetTo(m_CurrentScale, tempTime);
+                m_RotationInterpolator.ResetTo(m_CurrentRotation, tempTime);
+            }
+            base.OnNetworkObjectParentChanged(parentNetworkObject);
+        }
+
         /// <summary>
         /// Directly sets a state on the authoritative transform.
         /// Owner clients can directly set the state on a server authoritative transform
@@ -2656,6 +2677,12 @@ protected virtual void Update()
                 }
             }
 
+            // If we have not received any additional state updates since the very
+            // initial synchronization, then exit early.
+            if (m_LocalAuthoritativeNetworkState.IsSynchronizing)
+            {
+                return;
+            }
             // Apply the current authoritative state
             ApplyAuthoritativeState();
         }

com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs

@@ -38,10 +38,15 @@ public class NetworkPrefabs
         [NonSerialized]
         private List<NetworkPrefab> m_Prefabs = new List<NetworkPrefab>();
 
+        [NonSerialized]
+        private List<NetworkPrefab> m_RuntimeAddedPrefabs = new List<NetworkPrefab>();
+
         private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
         {
             if (AddPrefabRegistration(networkPrefab))
             {
+                // Don't add this to m_RuntimeAddedPrefabs
+                // This prefab is now in the PrefabList, so if we shutdown and initialize again, we'll pick it up from there.
                 m_Prefabs.Add(networkPrefab);
             }
         }
@@ -67,8 +72,6 @@ internal void Shutdown()
                 list.OnAdd -= AddTriggeredByNetworkPrefabList;
                 list.OnRemove -= RemoveTriggeredByNetworkPrefabList;
             }
-
-            NetworkPrefabsLists.Clear();
         }
 
         /// <summary>
@@ -77,13 +80,7 @@ internal void Shutdown()
         /// </summary>
         public void Initialize(bool warnInvalid = true)
         {
-            if (NetworkPrefabsLists.Count != 0 && m_Prefabs.Count > 0)
-            {
-                NetworkLog.LogWarning("Runtime Network Prefabs was not empty at initialization time. Network " +
-                    "Prefab registrations made before initialization will be replaced by NetworkPrefabsList.");
-                m_Prefabs.Clear();
-            }
-
+            m_Prefabs.Clear();
             foreach (var list in NetworkPrefabsLists)
             {
                 list.OnAdd += AddTriggeredByNetworkPrefabList;
@@ -93,7 +90,7 @@ public void Initialize(bool warnInvalid = true)
             NetworkPrefabOverrideLinks.Clear();
             OverrideToNetworkPrefab.Clear();
 
-            var prefabs = NetworkPrefabsLists.Count != 0 ? new List<NetworkPrefab>() : m_Prefabs;
+            var prefabs = new List<NetworkPrefab>();
 
             if (NetworkPrefabsLists.Count != 0)
             {
@@ -126,6 +123,18 @@ public void Initialize(bool warnInvalid = true)
                 }
             }
 
+            foreach (var networkPrefab in m_RuntimeAddedPrefabs)
+            {
+                if (AddPrefabRegistration(networkPrefab))
+                {
+                    m_Prefabs.Add(networkPrefab);
+                }
+                else
+                {
+                    removeList?.Add(networkPrefab);
+                }
+            }
+
             // Clear out anything that is invalid or not used
             if (removeList?.Count > 0)
             {
@@ -152,6 +161,7 @@ public bool Add(NetworkPrefab networkPrefab)
             if (AddPrefabRegistration(networkPrefab))
             {
                 m_Prefabs.Add(networkPrefab);
+                m_RuntimeAddedPrefabs.Add(networkPrefab);
                 return true;
             }
 
@@ -175,6 +185,7 @@ public void Remove(NetworkPrefab prefab)
             }
 
             m_Prefabs.Remove(prefab);
+            m_RuntimeAddedPrefabs.Remove(prefab);
             OverrideToNetworkPrefab.Remove(prefab.TargetPrefabGlobalObjectIdHash);
             NetworkPrefabOverrideLinks.Remove(prefab.SourcePrefabGlobalObjectIdHash);
         }
@@ -203,6 +214,15 @@ public void Remove(GameObject prefab)
                     return;
                 }
             }
+
+            for (int i = 0; i < m_RuntimeAddedPrefabs.Count; i++)
+            {
+                if (m_RuntimeAddedPrefabs[i].Prefab == prefab)
+                {
+                    Remove(m_RuntimeAddedPrefabs[i]);
+                    return;
+                }
+            }
         }
 
         /// <summary>

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

@@ -188,6 +188,12 @@ internal void GenerateGlobalObjectIdHash()
         /// </remarks>
         public Action OnMigratedToNewScene;
 
+        /// <summary>
+        /// When set to false, the NetworkObject will be spawned with no observers initially (other than the server)
+        /// </summary>
+        [Tooltip("When false, the NetworkObject will spawn with no observers initially. (default is true)")]
+        public bool SpawnWithObservers = true;
+
         /// <summary>
         /// Delegate type for checking visibility
         /// </summary>

com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs

@@ -786,9 +786,18 @@ private void SceneManager_ActiveSceneChanged(Scene current, Scene next)
         /// <returns>true (Valid) or false (Invalid)</returns>
         internal bool ValidateSceneBeforeLoading(uint sceneHash, LoadSceneMode loadSceneMode)
         {
-            var validated = true;
             var sceneName = SceneNameFromHash(sceneHash);
             var sceneIndex = SceneUtility.GetBuildIndexByScenePath(sceneName);
+            return ValidateSceneBeforeLoading(sceneIndex, sceneName, loadSceneMode);
+        }
+
+        /// <summary>
+        /// Overloaded version that is invoked by <see cref="ValidateSceneBeforeLoading"/> and <see cref="SynchronizeNetworkObjects"/>.
+        /// This specifically is to allow runtime generated scenes to be excluded by the server during synchronization.
+        /// </summary>
+        internal bool ValidateSceneBeforeLoading(int sceneIndex, string sceneName, LoadSceneMode loadSceneMode)
+        {
+            var validated = true;
             if (VerifySceneBeforeLoading != null)
             {
                 validated = VerifySceneBeforeLoading.Invoke(sceneIndex, sceneName, loadSceneMode);
@@ -1744,24 +1753,22 @@ internal void SynchronizeNetworkObjects(ulong clientId)
                     continue;
                 }
 
-                var sceneHash = SceneHashFromNameOrPath(scene.path);
-
                 // This would depend upon whether we are additive or not
                 // If we are the base scene, then we set the root scene index;
                 if (activeScene == scene)
                 {
-                    if (!ValidateSceneBeforeLoading(sceneHash, sceneEventData.LoadSceneMode))
+                    if (!ValidateSceneBeforeLoading(scene.buildIndex, scene.name, sceneEventData.LoadSceneMode))
                     {
                         continue;
                     }
-                    sceneEventData.SceneHash = sceneHash;
+                    sceneEventData.SceneHash = SceneHashFromNameOrPath(scene.path);
                     sceneEventData.SceneHandle = scene.handle;
                 }
-                else if (!ValidateSceneBeforeLoading(sceneHash, LoadSceneMode.Additive))
+                else if (!ValidateSceneBeforeLoading(scene.buildIndex, scene.name, LoadSceneMode.Additive))
                 {
                     continue;
                 }
-                sceneEventData.AddSceneToSynchronize(sceneHash, scene.handle);
+                sceneEventData.AddSceneToSynchronize(SceneHashFromNameOrPath(scene.path), scene.handle);
             }
 
             sceneEventData.AddSpawnedNetworkObjects();

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

@@ -617,8 +617,10 @@ private void SpawnNetworkObjectLocallyCommon(NetworkObject networkObject, ulong
                 }
             }
 
-            if (NetworkManager.IsServer)
+            // If we are the server and should spawn with observers
+            if (NetworkManager.IsServer && networkObject.SpawnWithObservers)
             {
+                // Add client observers
                 for (int i = 0; i < NetworkManager.ConnectedClientsList.Count; i++)
                 {
                     if (networkObject.CheckObjectVisibility == null || networkObject.CheckObjectVisibility(NetworkManager.ConnectedClientsList[i].ClientId))