style

Adding some additional comments in various places to help clarify a bit more what is happening.

Author: NoelStephensUnity

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

@@ -21,6 +21,10 @@ public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int
         {
             var networkManager = (NetworkManager)context.SystemOwner;
 #if UNIFIED_NETCODE
+            // Defer this message if the OnGhostSpawned trigger is still being processed. This is because the scene event message can be sent
+            // as part of the ghost spawning process and we want to make sure that all ghost spawning related messages are processed before we
+            // process this one. This is to avoid any potential issues with the order of message processing and to ensure that all ghost
+            // related messages are processed before we process this one.
             if (networkManager.DeferredMessageManager.HasAnyOfTrigger(IDeferredNetworkMessageManager.TriggerType
                     .OnGhostSpawned))
             {

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

@@ -1108,7 +1108,6 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
                     builder.AppendLine($"[Read][Synchronize Objects][WPos: {InternalBuffer.Position}][NO-Count: {newObjectsCount}] Begin:");
                 }
 #if UNIFIED_NETCODE
-                // TODO-UNIFIED: This is a temporary POC fix to handle hybrid spawning where the Ghost instance might not yet exist.
                 var spawnManager = m_NetworkManager.SpawnManager;
 #endif
 
@@ -1119,7 +1118,10 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
                     serializedObject.Deserialize(InternalBuffer);
 
 #if UNIFIED_NETCODE
-                    // TODO-UNIFIED: This is a temporary POC fix to handle synchronizing hybrid spawned objects where the Ghost instance might not yet exist.
+                    // This handles the case where a NetworkObject is serialized with a ghost component but the ghost isn't actually included in
+                    // the spawn message and won't be spawned by the client until later in the N4E synchronization process. In this case, we need
+                    // to defer the deserialization of the NetworkObject until the ghost is spawned and we have an instance to deserialize this 
+                    // information during synchronization.
                     if (serializedObject.HasGhost)
                     {
                         if (!networkManager.SpawnManager.GhostsPendingSpawn.ContainsKey(serializedObject.NetworkObjectId))
@@ -1442,12 +1444,18 @@ internal SceneEventData(NetworkManager networkManager)
     }
 
 #if UNIFIED_NETCODE
+    /// <summary>
+    /// Used to store pending ghost spawns that are waiting for their associated (N4E) ghost to be spawned before they can be fully deserialized and
+    /// spawned during the scene synchronization process. This is necessary because in unified mode we allow for NetworkObjects with ghost components
+    /// to be synchronized during the scene synchronization process but we can't guarantee the order of messages that the client receives so we
+    /// need to defer the deserialization of any NetworkObject that has a ghost component until we have received the message that the ghost has
+    /// been spawned and we have an instance to deserialize this information into.
+    /// </summary>
     internal struct PendingGhostSpawnEntry
     {
         public float RegistrationTime;
         public FastBufferReader Buffer;
         public NetworkObject.SerializedObject SerializedObject;
-
     }
 #endif
 }

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

@@ -1368,6 +1368,9 @@ internal bool AuthorityLocalSpawn([NotNull] NetworkObject networkObject, ulong n
             }
 
 #if UNIFIED_NETCODE
+            // If this is a hybrid prefab, the spawn authority is responsible for assigning the network object id to the network object bridge so that it
+            // can be used to link the N4E ghost to the NetworkObject. This is needed because in the hybrid prefab case, the ghost can be spawned before
+            // the NetworkObject is fully spawned.
             if (networkObject.HasGhost)
             {
                 networkObject.NetworkObjectBridge.SetNetworkObjectId(networkObject.NetworkObjectId);
@@ -2100,7 +2103,7 @@ internal void OnDespawnObject([NotNull] NetworkObject networkObject, bool destro
                 RemovePlayerObject(networkObject, destroyGameObject);
             }
 #if UNIFIED_NETCODE
-            // Let unified netcode handle destroying
+            // Unified netcode handles destroying the instance of the object on the non-authority side when the object has a ghost representation.
             if (destroyGameObject && networkObject.HasGhost && !NetworkManager.IsServer)
             {
                 // exit early