Renamed HasInstantiationPayload to HasInstantiationData to mantain naming coherency

Author: Extrys

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

@@ -2885,7 +2885,7 @@ public bool SpawnWithObservers
                 set => ByteUtility.SetBit(ref m_BitField, 10, value);
             }
 
-            public bool HasInstantiationPayload
+            public bool HasInstantiationData
             {
                 get => ByteUtility.GetBit(m_BitField, 11);
                 set => ByteUtility.SetBit(ref m_BitField, 11, value);
@@ -2979,10 +2979,10 @@ public void Serialize(FastBufferWriter writer)
                     writer.WriteValue(OwnerObject.GetSceneOriginHandle());
                 }
 
-                // Synchronize Payload, NetworkVariables and NetworkBehaviours
+                // Synchronize instantiation data, NetworkVariables and NetworkBehaviours
                 var bufferSerializer = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(writer));
 
-                if (HasInstantiationPayload)
+                if (HasInstantiationData)
                 {
                     OwnerObject.NetworkManager.PrefabHandler.SynchronizeInstantiationData(Hash, ref bufferSerializer);
                 }
@@ -3164,7 +3164,7 @@ internal SceneObject GetMessageSceneObject(ulong targetClientId = NetworkManager
                 Hash = CheckForGlobalObjectIdHashOverride(),
                 OwnerObject = this,
                 TargetClientId = targetClientId,
-                HasInstantiationPayload = NetworkManager.PrefabHandler.ContainsHandlerWithData(GlobalObjectIdHash),
+                HasInstantiationData = NetworkManager.PrefabHandler.ContainsHandlerWithData(GlobalObjectIdHash),
             };
 
             // Handle Parenting
@@ -3231,8 +3231,8 @@ internal static NetworkObject AddSceneObject(in SceneObject sceneObject, FastBuf
         {
             var bufferSerializer = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(reader));
 
-            //Synchronize the instantiation payload if needed
-            if (sceneObject.HasInstantiationPayload)
+            //Synchronize the instantiation data if needed
+            if (sceneObject.HasInstantiationData)
             {
                 networkManager.PrefabHandler.SynchronizeInstantiationData(sceneObject.Hash, ref bufferSerializer);
             }

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

@@ -268,58 +268,58 @@ internal void SynchronizeInstantiationData<T>(uint objectHash, ref BufferSeriali
 
             if (serializer.IsWriter)
             {
-                // Reserves space to write the size later
+                // Reserves space to write the instantiation data size later
                 FastBufferWriter fastBufferWriter = serializer.GetFastBufferWriter();
-                int sizePos = fastBufferWriter.Position;
+                int dataSizePos = fastBufferWriter.Position;
                 fastBufferWriter.WriteValueSafe(0); // placeholder for size, correctly writen at the end
 
-                int payloadStartPos = fastBufferWriter.Position;
+                int dataStartPos = fastBufferWriter.Position;
                 try
                 {
                     synchronizableHandler.OnSynchronizeInstantiationData(ref serializer);
                 }
                 catch (Exception ex)
                 {
                     // Resets to start position to avoid writing corrupted data
-                    fastBufferWriter.Seek(sizePos);
-                    NetworkLog.LogError($"[InstantiationPayload] Handler failed during synchronization (Write): {ex.Message}");
+                    fastBufferWriter.Seek(dataSizePos);
+                    NetworkLog.LogError($"[InstantiationData] Handler failed during synchronization (Write): {ex.Message}");
                     return;
                 }
 
-                // Compute and write actual payload size
-                int payloadEndPos = fastBufferWriter.Position;
-                int payloadSize = payloadEndPos - payloadStartPos;
+                // Compute and write actual instantiation data size
+                int dataEndPos = fastBufferWriter.Position;
+                int dataSize = dataEndPos - dataStartPos;
                 // Goes back and write the real size
-                fastBufferWriter.Seek(sizePos);
-                fastBufferWriter.WriteValueSafe(payloadSize);
+                fastBufferWriter.Seek(dataSizePos);
+                fastBufferWriter.WriteValueSafe(dataSize);
                 // Restores to end
-                fastBufferWriter.Seek(payloadEndPos);
+                fastBufferWriter.Seek(dataEndPos);
             }
             else
             {
                 FastBufferReader fastBufferReader = serializer.GetFastBufferReader();
-                // Reads the expected size of the payload
-                fastBufferReader.ReadValueSafe(out int payloadSize);
-                int payloadStartPos = fastBufferReader.Position;
+                // Reads the expected size of the instantiation data
+                fastBufferReader.ReadValueSafe(out int dataSize);
+                int dataStartPos = fastBufferReader.Position;
 
                 try
                 {
                     synchronizableHandler.OnSynchronizeInstantiationData(ref serializer);
                 }
                 catch (Exception ex)
                 {
-                    // Skips the unread payload bytes
-                    fastBufferReader.Seek(payloadStartPos + payloadSize);
-                    NetworkLog.LogError($"[InstantiationPayload] Handler failed during synchronization (Read): {ex.Message}");
+                    // Skips the unread instantiation data bytes
+                    fastBufferReader.Seek(dataStartPos + dataSize);
+                    NetworkLog.LogError($"[InstantiationData] Handler failed during synchronization (Read): {ex.Message}");
                     return;
                 }
 
                 // Validates if expected number of bytes were read
-                int payloadEndPos = fastBufferReader.Position;
-                if (payloadEndPos != payloadStartPos + payloadSize)
+                int dataEndPos = fastBufferReader.Position;
+                if (dataEndPos != dataStartPos + dataSize)
                 {
-                    NetworkLog.LogWarning($"[InstantiationPayload] Read {payloadEndPos - payloadStartPos} bytes, expected {payloadSize}");
-                    fastBufferReader.Seek(payloadStartPos + payloadSize);
+                    NetworkLog.LogWarning($"[InstantiationData] Read {dataEndPos - dataStartPos} bytes, expected {dataSize}");
+                    fastBufferReader.Seek(dataStartPos + dataSize);
                 }
             }
         }