Rename pass

SceneObject -- > SerializedObject
GetMessageSceneObject --> Serialize
AddSceneObject --> Deserialize

Author: noellie-velez

com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs

@@ -1119,15 +1119,15 @@ internal void ApprovedPlayerSpawn(ulong clientId, uint playerPrefabHash)
 
                 var message = new CreateObjectMessage
                 {
-                    ObjectSynchronizerInfo = ConnectedClients[clientId].PlayerObject.GetMessageForSynchronization(clientPair.Key),
+                    ObjectInfo = ConnectedClients[clientId].PlayerObject.Serialize(clientPair.Key),
                     IncludesSerializedObject = true,
                 };
 
-                message.ObjectSynchronizerInfo.Hash = playerPrefabHash;
-                message.ObjectSynchronizerInfo.IsSceneObject = false;
-                message.ObjectSynchronizerInfo.HasParent = false;
-                message.ObjectSynchronizerInfo.IsPlayerObject = true;
-                message.ObjectSynchronizerInfo.OwnerClientId = clientId;
+                message.ObjectInfo.Hash = playerPrefabHash;
+                message.ObjectInfo.IsSceneObject = false;
+                message.ObjectInfo.HasParent = false;
+                message.ObjectInfo.IsPlayerObject = true;
+                message.ObjectInfo.OwnerClientId = clientId;
                 var size = SendMessage(ref message, MessageDeliveryType<CreateObjectMessage>.DefaultDelivery, clientPair.Key);
                 NetworkManager.NetworkMetrics.TrackObjectSpawnSent(clientPair.Key, ConnectedClients[clientId].PlayerObject, size);
             }

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

@@ -2842,7 +2842,7 @@ public NetworkBehaviour GetNetworkBehaviourAtOrderIndex(ushort index)
             return ChildNetworkBehaviours[index];
         }
 
-        internal struct NetworkObjectSynchronizer
+        internal struct SerializedObject
         {
             public uint Hash;
             public ulong NetworkObjectId;
@@ -3171,9 +3171,9 @@ internal void SynchronizeNetworkBehaviours<T>(ref BufferSerializer<T> serializer
             }
         }
 
-        internal NetworkObjectSynchronizer GetMessageForSynchronization(ulong targetClientId = NetworkManager.ServerClientId, bool syncObservers = false)
+        internal SerializedObject Serialize(ulong targetClientId = NetworkManager.ServerClientId, bool syncObservers = false)
         {
-            var obj = new NetworkObjectSynchronizer
+            var obj = new SerializedObject
             {
                 HasParent = transform.parent != null,
                 WorldPositionStays = m_CachedWorldPositionStays,
@@ -3227,7 +3227,7 @@ internal NetworkObjectSynchronizer GetMessageForSynchronization(ulong targetClie
                     syncScaleLocalSpaceRelative = obj.HasParent;
                 }
 
-                obj.Transform = new NetworkObjectSynchronizer.TransformData
+                obj.Transform = new SerializedObject.TransformData
                 {
                     // If we are parented and we have the m_CachedWorldPositionStays disabled, then use local space
                     // values as opposed world space values.
@@ -3246,35 +3246,35 @@ internal NetworkObjectSynchronizer GetMessageForSynchronization(ulong targetClie
         }
 
         /// <summary>
-        /// Used to deserialize a serialized <see cref="NetworkObjectSynchronizer"/> which occurs
+        /// Used to deserialize a serialized <see cref="SerializedObject"/> which occurs
         /// when the client is approved or during a scene transition
         /// </summary>
-        /// <param name="networkObjectSynchronizer">Deserialized scene object data</param>
+        /// <param name="serializedObject">Deserialized scene object data</param>
         /// <param name="reader">FastBufferReader for the NetworkVariable data</param>
         /// <param name="networkManager">NetworkManager instance</param>
         /// <param name="invokedByMessage">will be true if invoked by CreateObjectMessage</param>
         /// <returns>The deserialized NetworkObject or null if deserialization failed</returns>
-        internal static NetworkObject AddClientNetworkObject(in NetworkObjectSynchronizer networkObjectSynchronizer, FastBufferReader reader, NetworkManager networkManager, bool invokedByMessage = false)
+        internal static NetworkObject Deserialize(in SerializedObject serializedObject, FastBufferReader reader, NetworkManager networkManager, bool invokedByMessage = false)
         {
-            var endOfSynchronizationData = reader.Position + networkObjectSynchronizer.SynchronizationDataSize;
+            var endOfSynchronizationData = reader.Position + serializedObject.SynchronizationDataSize;
 
             byte[] instantiationData = null;
-            if (networkObjectSynchronizer.HasInstantiationData)
+            if (serializedObject.HasInstantiationData)
             {
                 reader.ReadValueSafe(out instantiationData);
             }
 
 
             // Attempt to create a local NetworkObject
-            var networkObject = networkManager.SpawnManager.CreateLocalNetworkObject(networkObjectSynchronizer, instantiationData);
+            var networkObject = networkManager.SpawnManager.CreateLocalNetworkObject(serializedObject, instantiationData);
 
 
             if (networkObject == null)
             {
                 // Log the error that the NetworkObject failed to construct
                 if (networkManager.LogLevel <= LogLevel.Normal)
                 {
-                    NetworkLog.LogError($"Failed to spawn {nameof(NetworkObject)} for Hash {networkObjectSynchronizer.Hash}.");
+                    NetworkLog.LogError($"Failed to spawn {nameof(NetworkObject)} for Hash {serializedObject.Hash}.");
                 }
 
                 try
@@ -3295,7 +3295,7 @@ internal static NetworkObject AddClientNetworkObject(in NetworkObjectSynchronize
 
             // This will get set again when the NetworkObject is spawned locally, but we set it here ahead of spawning
             // in order to be able to determine which NetworkVariables the client will be allowed to read.
-            networkObject.OwnerClientId = networkObjectSynchronizer.OwnerClientId;
+            networkObject.OwnerClientId = serializedObject.OwnerClientId;
 
             // Special Case: Invoke NetworkBehaviour.OnPreSpawn methods here before SynchronizeNetworkBehaviours
             networkObject.InvokeBehaviourNetworkPreSpawn();
@@ -3323,7 +3323,7 @@ internal static NetworkObject AddClientNetworkObject(in NetworkObjectSynchronize
             // being told we do not have a parent, then we want to clear the latest parent so it is not automatically
             // "re-parented" to the original parent. This can happen if not unloading the scene and the parenting of
             // the in-scene placed Networkobject changes several times over different sessions.
-            if (networkObjectSynchronizer.IsSceneObject && !networkObjectSynchronizer.HasParent && networkObject.m_LatestParent.HasValue)
+            if (serializedObject.IsSceneObject && !serializedObject.HasParent && networkObject.m_LatestParent.HasValue)
             {
                 networkObject.m_LatestParent = null;
             }
@@ -3336,19 +3336,19 @@ internal static NetworkObject AddClientNetworkObject(in NetworkObjectSynchronize
 
             // Invoke the non-authority local spawn method
             // (It also invokes post spawn and handles processing derferred messages)
-            networkManager.SpawnManager.NonAuthorityLocalSpawn(networkObject, networkObjectSynchronizer, networkObjectSynchronizer.DestroyWithScene);
+            networkManager.SpawnManager.NonAuthorityLocalSpawn(networkObject, serializedObject, serializedObject.DestroyWithScene);
 
-            if (networkObjectSynchronizer.SyncObservers)
+            if (serializedObject.SyncObservers)
             {
-                foreach (var observer in networkObjectSynchronizer.Observers)
+                foreach (var observer in serializedObject.Observers)
                 {
                     networkObject.Observers.Add(observer);
                 }
             }
 
             if (networkManager.DistributedAuthorityMode)
             {
-                networkObject.SpawnWithObservers = networkObjectSynchronizer.SpawnWithObservers;
+                networkObject.SpawnWithObservers = serializedObject.SpawnWithObservers;
             }
 
             // If this was not invoked by a message handler, we are in distributed authority mode, and we are spawning with observers or

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

@@ -160,7 +160,7 @@ public void Serialize(FastBufferWriter writer, int targetVersion)
                     {
                         sobj.Observers.Add(OwnerClientId);
                         // In distributed authority mode, we send the currently known observers of each NetworkObject to the client being synchronized.
-                        var sceneObject = sobj.GetMessageForSynchronization(OwnerClientId, IsDistributedAuthority);
+                        var sceneObject = sobj.Serialize(OwnerClientId, IsDistributedAuthority);
                         sceneObject.Serialize(writer);
                         ++sceneObjectCount;
                     }
@@ -342,9 +342,9 @@ public void Handle(ref NetworkContext context)
                 // to create a list to hold the data. This is a breach of convention for performance reasons.
                 for (ushort i = 0; i < sceneObjectCount; i++)
                 {
-                    var sceneObject = new NetworkObject.NetworkObjectSynchronizer();
+                    var sceneObject = new NetworkObject.SerializedObject();
                     sceneObject.Deserialize(m_ReceivedSceneObjectData);
-                    NetworkObject.AddClientNetworkObject(sceneObject, m_ReceivedSceneObjectData, networkManager);
+                    NetworkObject.Deserialize(sceneObject, m_ReceivedSceneObjectData, networkManager);
                 }
 
                 if (networkManager.AutoSpawnPlayerPrefabClientSide)

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

@@ -9,7 +9,7 @@ internal struct CreateObjectMessage : INetworkMessage
 
         private const string k_Name = "CreateObjectMessage";
 
-        public NetworkObject.NetworkObjectSynchronizer ObjectSynchronizerInfo;
+        public NetworkObject.SerializedObject ObjectInfo;
         private FastBufferReader m_ReceivedNetworkVariableData;
 
         // DA - NGO CMB SERVICE NOTES:
@@ -64,7 +64,7 @@ public void Serialize(FastBufferWriter writer, int targetVersion)
 
             if (IncludesSerializedObject)
             {
-                ObjectSynchronizerInfo.Serialize(writer);
+                ObjectInfo.Serialize(writer);
             }
             else
             {
@@ -113,16 +113,16 @@ public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int
 
             if (IncludesSerializedObject)
             {
-                ObjectSynchronizerInfo.Deserialize(reader);
+                ObjectInfo.Deserialize(reader);
             }
             else
             {
                 ByteUnpacker.ReadValuePacked(reader, out NetworkObjectId);
             }
 
-            if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectSynchronizerInfo))
+            if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectSynchronizerInfo.Hash, reader, ref context, k_Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context, k_Name);
                 return false;
             }
             m_ReceivedNetworkVariableData = reader;
@@ -136,18 +136,18 @@ public void Handle(ref NetworkContext context)
             // If a client receives a create object message and it is still synchronizing, then defer the object creation until it has finished synchronizing
             if (networkManager.SceneManager.ShouldDeferCreateObject())
             {
-                networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectSynchronizerInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
+                networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
             }
             else
             {
                 if (networkManager.DistributedAuthorityMode && !IncludesSerializedObject && UpdateObservers)
                 {
-                    ObjectSynchronizerInfo = new NetworkObject.NetworkObjectSynchronizer()
+                    ObjectInfo = new NetworkObject.SerializedObject()
                     {
                         NetworkObjectId = NetworkObjectId,
                     };
                 }
-                CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectSynchronizerInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
+                CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
             }
         }
 
@@ -158,46 +158,46 @@ internal static void CreateObject(ref NetworkManager networkManager, ref Network
             var observerIds = deferredObjectCreation.ObserverIds;
             var newObserverIds = deferredObjectCreation.NewObserverIds;
             var messageSize = deferredObjectCreation.MessageSize;
-            var sceneObject = deferredObjectCreation.NetworkObjectSynchronizer;
+            var sceneObject = deferredObjectCreation.SerializedObject;
             var networkVariableData = deferredObjectCreation.FastBufferReader;
             CreateObject(ref networkManager, senderId, messageSize, sceneObject, networkVariableData, observerIds, newObserverIds);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.NetworkObjectSynchronizer networkObjectSynchronizer, FastBufferReader networkVariableData, ulong[] observerIds, ulong[] newObserverIds)
+        internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.SerializedObject serializedObject, FastBufferReader networkVariableData, ulong[] observerIds, ulong[] newObserverIds)
         {
             var networkObject = (NetworkObject)null;
             try
             {
                 if (!networkManager.DistributedAuthorityMode)
                 {
-                    networkObject = NetworkObject.AddClientNetworkObject(networkObjectSynchronizer, networkVariableData, networkManager);
+                    networkObject = NetworkObject.Deserialize(serializedObject, networkVariableData, networkManager);
                 }
                 else
                 {
                     var hasObserverIdList = observerIds != null && observerIds.Length > 0;
                     var hasNewObserverIdList = newObserverIds != null && newObserverIds.Length > 0;
                     // Depending upon visibility of the NetworkObject and the client in question, it could be that
                     // this client already has visibility of this NetworkObject
-                    if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(networkObjectSynchronizer.NetworkObjectId))
+                    if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(serializedObject.NetworkObjectId))
                     {
                         // If so, then just get the local instance
-                        networkObject = networkManager.SpawnManager.SpawnedObjects[networkObjectSynchronizer.NetworkObjectId];
+                        networkObject = networkManager.SpawnManager.SpawnedObjects[serializedObject.NetworkObjectId];
 
                         // This should not happen, logging error just in case
                         if (hasNewObserverIdList && newObserverIds.Contains(networkManager.LocalClientId))
                         {
-                            NetworkLog.LogErrorServer($"[{nameof(CreateObjectMessage)}][Duplicate-Broadcast] Detected duplicated object creation for {networkObjectSynchronizer.NetworkObjectId}!");
+                            NetworkLog.LogErrorServer($"[{nameof(CreateObjectMessage)}][Duplicate-Broadcast] Detected duplicated object creation for {serializedObject.NetworkObjectId}!");
                         }
                         else // Trap to make sure the owner is not receiving any messages it sent
                         if (networkManager.CMBServiceConnection && networkManager.LocalClientId == networkObject.OwnerClientId)
                         {
-                            NetworkLog.LogWarning($"[{nameof(CreateObjectMessage)}][Client-{networkManager.LocalClientId}][Duplicate-CreateObjectMessage][Client Is Owner] Detected duplicated object creation for {networkObject.name}-{networkObjectSynchronizer.NetworkObjectId}!");
+                            NetworkLog.LogWarning($"[{nameof(CreateObjectMessage)}][Client-{networkManager.LocalClientId}][Duplicate-CreateObjectMessage][Client Is Owner] Detected duplicated object creation for {networkObject.name}-{serializedObject.NetworkObjectId}!");
                         }
                     }
                     else
                     {
-                        networkObject = NetworkObject.AddClientNetworkObject(networkObjectSynchronizer, networkVariableData, networkManager, true);
+                        networkObject = NetworkObject.Deserialize(serializedObject, networkVariableData, networkManager, true);
                     }
 
                     // DA - NGO CMB SERVICE NOTES:
@@ -229,7 +229,7 @@ internal static void CreateObject(ref NetworkManager networkManager, ulong sende
 
                         var createObjectMessage = new CreateObjectMessage()
                         {
-                            ObjectSynchronizerInfo = networkObjectSynchronizer,
+                            ObjectInfo = serializedObject,
                             m_ReceivedNetworkVariableData = networkVariableData,
                             ObserverIds = hasObserverIdList ? observerIds : null,
                             NetworkObjectId = networkObject.NetworkObjectId,

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

@@ -38,7 +38,6 @@ internal struct ParentSyncMessage : INetworkMessage
 
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
-
             byte bitset = 0x00;
             if (WorldPositionStays) { bitset |= k_WorldPositionStays; }
             if (IsLatestParentSet) { bitset |= k_IsLatestParentSet; }

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

@@ -3034,23 +3034,23 @@ internal struct DeferredObjectCreation
             // When we transfer session owner and we are using a DAHost, this will be pertinent (otherwise it is not when connected to a DA service)
             internal ulong[] ObserverIds;
             internal ulong[] NewObserverIds;
-            internal NetworkObject.NetworkObjectSynchronizer NetworkObjectSynchronizer;
+            internal NetworkObject.SerializedObject SerializedObject;
             internal FastBufferReader FastBufferReader;
         }
 
         internal List<DeferredObjectCreation> DeferredObjectCreationList = new List<DeferredObjectCreation>();
         internal int DeferredObjectCreationCount;
 
         // The added clientIds is specific to DAHost when session ownership changes and a normal client is controlling scene loading
-        internal void DeferCreateObject(ulong senderId, uint messageSize, NetworkObject.NetworkObjectSynchronizer networkObjectSynchronizer, FastBufferReader fastBufferReader, ulong[] observerIds, ulong[] newObserverIds)
+        internal void DeferCreateObject(ulong senderId, uint messageSize, NetworkObject.SerializedObject serializedObject, FastBufferReader fastBufferReader, ulong[] observerIds, ulong[] newObserverIds)
         {
             var deferredObjectCreationEntry = new DeferredObjectCreation()
             {
                 SenderId = senderId,
                 MessageSize = messageSize,
                 ObserverIds = observerIds,
                 NewObserverIds = newObserverIds,
-                NetworkObjectSynchronizer = networkObjectSynchronizer,
+                SerializedObject = serializedObject,
             };
 
             unsafe