Simplified approach that reuses createObjectMesage bufferSerializer

Author: Extrys

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

@@ -797,9 +797,8 @@ internal void HandleConnectionApproval(ulong ownerClientId, NetworkManager.Conne
                 // Server-side spawning (only if there is a prefab hash or player prefab provided)
                 if (!NetworkManager.DistributedAuthorityMode && response.CreatePlayerObject && (response.PlayerPrefabHash.HasValue || NetworkManager.NetworkConfig.PlayerPrefab != null))
                 {
-                    var instantiationPayloadWriter = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(new FastBufferWriter(16,Allocator.Temp, int.MaxValue)));
-                    var playerObject = response.PlayerPrefabHash.HasValue ? NetworkManager.SpawnManager.GetNetworkObjectToSpawn(response.PlayerPrefabHash.Value, ownerClientId, ref instantiationPayloadWriter, response.Position ?? null, response.Rotation ?? null)
-                    : NetworkManager.SpawnManager.GetNetworkObjectToSpawn(NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash, ownerClientId, ref instantiationPayloadWriter, response.Position ?? null, response.Rotation ?? null);
+                    var playerObject = response.PlayerPrefabHash.HasValue ? NetworkManager.SpawnManager.GetNetworkObjectToSpawn(response.PlayerPrefabHash.Value, ownerClientId, response.Position ?? null, response.Rotation ?? null)
+                    : NetworkManager.SpawnManager.GetNetworkObjectToSpawn(NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash, ownerClientId, response.Position ?? null, response.Rotation ?? null);
 
                     // Spawn the player NetworkObject locally
                     NetworkManager.SpawnManager.SpawnNetworkObjectLocally(
@@ -951,8 +950,7 @@ internal void CreateAndSpawnPlayer(ulong ownerId)
                 if (playerPrefab != null)
                 {
                     var globalObjectIdHash = playerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
-                    var instantiationPayloadWriter = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(new FastBufferWriter(16, Allocator.Temp, int.MaxValue)));
-                    var networkObject = NetworkManager.SpawnManager.GetNetworkObjectToSpawn(globalObjectIdHash, ownerId, ref instantiationPayloadWriter, playerPrefab.transform.position, playerPrefab.transform.rotation);
+                    var networkObject = NetworkManager.SpawnManager.GetNetworkObjectToSpawn(globalObjectIdHash, ownerId, playerPrefab.transform.position, playerPrefab.transform.rotation);
                     networkObject.IsSceneObject = false;
                     networkObject.SpawnAsPlayerObject(ownerId, networkObject.DestroyWithScene);
                 }

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

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
-using Unity.Collections;
 using Unity.Netcode.Components;
 #if UNITY_EDITOR
 using UnityEditor;
@@ -46,13 +45,6 @@ public sealed class NetworkObject : MonoBehaviour
         [SerializeField]
         internal uint InScenePlacedSourceGlobalObjectIdHash;
 
-        /// <summary>
-        /// Metadata sent during the instantiation process.
-        /// Retrieved in INetworkCustomSpawnDataSynchronizer before instantiation,
-        /// and available to INetworkPrefabInstanceHandler.Instantiate() for custom handling by user code.
-        /// </summary>
-        internal FastBufferReader InstantiationPayload;
-
         /// <summary>
         /// Gets the Prefab Hash Id of this object if the object is registerd as a prefab otherwise it returns 0
         /// </summary>
@@ -1819,8 +1811,6 @@ internal void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool pla
                 }
             }
 
-            NetworkManager.PrefabHandler.InjectInstantiationPayload(this);
-
             NetworkManager.SpawnManager.SpawnNetworkObjectLocally(this, NetworkManager.SpawnManager.GetNetworkObjectId(), IsSceneObject.HasValue && IsSceneObject.Value, playerObject, ownerClientId, destroyWithScene);
 
             if ((NetworkManager.DistributedAuthorityMode && NetworkManager.DAHost) || (!NetworkManager.DistributedAuthorityMode && NetworkManager.IsServer))
@@ -2822,7 +2812,6 @@ internal struct SceneObject
             public ulong NetworkObjectId;
             public ulong OwnerClientId;
             public ushort OwnershipFlags;
-            public FastBufferReader InstantiationPayload;
 
             public bool IsPlayerObject
             {
@@ -2965,26 +2954,12 @@ public void Serialize(FastBufferWriter writer)
                 var writeSize = 0;
                 writeSize += HasTransform ? FastBufferWriter.GetWriteSize<TransformData>() : 0;
                 writeSize += FastBufferWriter.GetWriteSize<int>();
-                if (HasInstantiationPayload)
-                {
-                    writeSize += FastBufferWriter.GetWriteSize<int>();
-                    writeSize += InstantiationPayload.Length;
-                }
 
                 if (!writer.TryBeginWrite(writeSize))
                 {
                     throw new OverflowException("Could not serialize SceneObject: Out of buffer space.");
                 }
 
-                if (HasInstantiationPayload)
-                {
-                    writer.WriteValueSafe(InstantiationPayload.Length);
-                    unsafe
-                    {
-                        writer.WriteBytes(InstantiationPayload.GetUnsafePtr(), InstantiationPayload.Length);
-                    }
-                }
-
                 if (HasTransform)
                 {
                     writer.WriteValue(Transform);
@@ -3001,8 +2976,15 @@ public void Serialize(FastBufferWriter writer)
                     writer.WriteValue(OwnerObject.GetSceneOriginHandle());
                 }
 
-                // Synchronize NetworkVariables and NetworkBehaviours
+                // Synchronize Payload, NetworkVariables and NetworkBehaviours
                 var bufferSerializer = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(writer));
+
+                if (HasInstantiationPayload)
+                {
+                    if (NetworkManager.Singleton.PrefabHandler.TryGetPayloadSynchronizer(Hash, out INetworkInstantiationPayloadSynchronizer synchronizer))
+                        synchronizer.OnSynchronize(ref bufferSerializer);
+                }
+
                 OwnerObject.SynchronizeNetworkBehaviours(ref bufferSerializer, TargetClientId);
             }
 
@@ -3045,34 +3027,12 @@ public void Deserialize(FastBufferReader reader)
                 readSize += HasTransform ? FastBufferWriter.GetWriteSize<TransformData>() : 0;
                 readSize += FastBufferWriter.GetWriteSize<int>();
 
-                int preInstanceDataSize = 0;
-                if (HasInstantiationPayload)
-                {
-                    if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize<int>()))
-                    {
-                        throw new OverflowException($"Could not deserialize SceneObject: Reading past the end of the buffer ({nameof(InstantiationPayload)} size)");
-                    }
-
-                    reader.ReadValueSafe(out preInstanceDataSize);
-                    readSize += FastBufferWriter.GetWriteSize<int>();
-                    readSize += preInstanceDataSize;
-                }
-
                 // Try to begin reading the remaining bytes
                 if (!reader.TryBeginRead(readSize))
                 {
                     throw new OverflowException("Could not deserialize SceneObject: Reading past the end of the buffer");
                 }
 
-                if (HasInstantiationPayload)
-                {
-                    unsafe
-                    {
-                        InstantiationPayload = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, preInstanceDataSize);
-                        reader.Seek(reader.Position + preInstanceDataSize);
-                    }
-                }
-
                 if (HasTransform)
                 {
                     reader.ReadValue(out Transform);
@@ -3081,6 +3041,15 @@ public void Deserialize(FastBufferReader reader)
                 // The NetworkSceneHandle is the server-side relative
                 // scene handle that the NetworkObject resides in.
                 reader.ReadValue(out NetworkSceneHandle);
+
+                if (HasInstantiationPayload)
+                {
+                    if (NetworkManager.Singleton.PrefabHandler.TryGetPayloadSynchronizer(Hash, out INetworkInstantiationPayloadSynchronizer synchronizer))
+                    {
+                        var instantiationPayloadBufferReader = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(reader));
+                        synchronizer.OnSynchronize(ref instantiationPayloadBufferReader);
+                    }
+                }
             }
         }
 
@@ -3202,8 +3171,7 @@ internal SceneObject GetMessageSceneObject(ulong targetClientId = NetworkManager
                 Hash = CheckForGlobalObjectIdHashOverride(),
                 OwnerObject = this,
                 TargetClientId = targetClientId,
-                HasInstantiationPayload = InstantiationPayload.IsInitialized,
-                InstantiationPayload = InstantiationPayload
+                HasInstantiationPayload = NetworkManager.PrefabHandler.HasPayloadSynchronizer(GlobalObjectIdHash),
             };
 
             // Handle Parenting
@@ -3298,11 +3266,6 @@ internal static NetworkObject AddSceneObject(in SceneObject sceneObject, FastBuf
             // in order to be able to determine which NetworkVariables the client will be allowed to read.
             networkObject.OwnerClientId = sceneObject.OwnerClientId;
 
-            // Even though the Instantiation Payload is typically consumed during the spawn message handling phase,
-            // we still assign it here to preserve the original spawn metadata for potential inspection, diagnostics,
-            // or in case future systems want to access it directly without relying on synchronization messages.
-            networkObject.InstantiationPayload = sceneObject.InstantiationPayload;
-
             // Special Case: Invoke NetworkBehaviour.OnPreSpawn methods here before SynchronizeNetworkBehaviours
             networkObject.InvokeBehaviourNetworkPreSpawn();
 

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

@@ -16,5 +16,7 @@ public interface INetworkInstantiationPayloadSynchronizer
         /// </summary>
         /// <param name="serializer">The buffer serializer used to read or write custom instantiation data.</param>
         void OnSynchronize<T>(ref BufferSerializer<T> serializer) where T : IReaderWriter;
-	}
+        void Serialize(FastBufferWriter writer);
+        void Deserialize(FastBufferReader reader);
+    }
 }

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Unity.Collections;
 using UnityEngine;
 
 namespace Unity.Netcode
@@ -226,29 +227,33 @@ public bool RemoveHandler(uint globalObjectIdHash)
         /// <returns>true or false</returns>
         internal bool ContainsHandler(uint networkPrefabHash) => m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabHash) || m_PrefabInstanceToPrefabAsset.ContainsKey(networkPrefabHash);
 
-        /// <summary>
-        /// Injects instantiation payload on the networkObject
-        /// </summary>
-        /// <param name="networkObject">Injection target</param>
-        internal void InjectInstantiationPayload(NetworkObject networkObject)
+        internal bool HasPayloadSynchronizer(uint objectHash) => TryGetPayloadSynchronizer(objectHash, out _);
+        internal bool TryGetPayloadSynchronizer(uint objectHash, out INetworkInstantiationPayloadSynchronizer synchronizer)
+        {
+            if (m_PrefabAssetToPrefabHandler.TryGetValue(objectHash, out var prefabInstanceHandler))
+            {
+                if (prefabInstanceHandler is INetworkInstantiationPayloadSynchronizer payloadSynchronizer)
+                {
+                    synchronizer = payloadSynchronizer;
+                    return true;
+                }
+            }
+            synchronizer = null;
+            return false;
+        }
+
+        internal void ReadInstantiationPayload(uint objectHash, FastBufferReader reader)
         {
-            if (m_PrefabAssetToPrefabHandler.TryGetValue(networkObject.GlobalObjectIdHash, out var prefabInstanceHandler))
+            if (m_PrefabAssetToPrefabHandler.TryGetValue(objectHash, out var prefabInstanceHandler))
             {
                 if (prefabInstanceHandler is INetworkInstantiationPayloadSynchronizer synchronizer)
                 {
-                    var fastBufferWriter = new FastBufferWriter(16, Collections.Allocator.Temp, int.MaxValue);
-                    var instantiationPayloadBufferWriter = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(fastBufferWriter));
-                    synchronizer.OnSynchronize(ref instantiationPayloadBufferWriter);
-                    if (fastBufferWriter.Length > 0)
-                    {
-                        unsafe
-                        {
-                            networkObject.InstantiationPayload = new FastBufferReader(fastBufferWriter.GetUnsafePtr(), Collections.Allocator.Persistent, fastBufferWriter.Length);
-                        }
-                    }
+                    var instantiationPayloadBufferReader = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(reader));
+                    synchronizer.OnSynchronize(ref instantiationPayloadBufferReader);
                 }
             }
         }
+     
 
         /// <summary>
         /// Returns the source NetworkPrefab's <see cref="NetworkObject.GlobalObjectIdHash"/>
@@ -279,20 +284,10 @@ internal uint GetSourceGlobalObjectIdHash(uint networkPrefabHash)
         /// <param name="position"></param>
         /// <param name="rotation"></param>
         /// <returns></returns>
-        internal NetworkObject HandleNetworkPrefabSpawn<T>(uint networkPrefabAssetHash, ulong ownerClientId, ref BufferSerializer<T> InstantiationPayloadSerializer, Vector3 position, Quaternion rotation) where T : IReaderWriter
+        internal NetworkObject HandleNetworkPrefabSpawn(uint networkPrefabAssetHash, ulong ownerClientId, Vector3 position, Quaternion rotation)
         {
             if (m_PrefabAssetToPrefabHandler.TryGetValue(networkPrefabAssetHash, out var prefabInstanceHandler))
             {
-                if (InstantiationPayloadSerializer.IsReader)
-                {
-                    FastBufferReader instantiationPayloadReader = InstantiationPayloadSerializer.GetFastBufferReader();
-                    bool ShouldSychronize = instantiationPayloadReader.IsInitialized && instantiationPayloadReader.Length > 0;
-                    if (ShouldSychronize && prefabInstanceHandler is INetworkInstantiationPayloadSynchronizer synchronizer)
-                    {
-                        synchronizer.OnSynchronize(ref InstantiationPayloadSerializer);
-                    }
-                }
-
                 var networkObjectInstance = prefabInstanceHandler.Instantiate(ownerClientId, position, rotation);
 
                 //Now we must make sure this alternate PrefabAsset spawned in place of the prefab asset with the networkPrefabAssetHash (GlobalObjectIdHash)

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

@@ -749,7 +749,7 @@ internal NetworkObject InstantiateAndSpawnNoParameterChecks(NetworkObject networ
             if (forceOverride || NetworkManager.IsClient || NetworkManager.DistributedAuthorityMode || NetworkManager.PrefabHandler.ContainsHandler(networkPrefab.GlobalObjectIdHash))
             {
                 var intantiationPayloadWriter = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(new FastBufferWriter(16, Collections.Allocator.Temp, int.MaxValue)));
-                networkObject = GetNetworkObjectToSpawn(networkPrefab.GlobalObjectIdHash, ownerClientId, ref intantiationPayloadWriter, position, rotation);
+                networkObject = GetNetworkObjectToSpawn(networkPrefab.GlobalObjectIdHash, ownerClientId, position, rotation);
             }
             else // Under this case, server instantiate the prefab passed in.
             {
@@ -780,14 +780,14 @@ internal NetworkObject InstantiateAndSpawnNoParameterChecks(NetworkObject networ
         /// Gets the right NetworkObject prefab instance to spawn. If a handler is registered or there is an override assigned to the
         /// passed in globalObjectIdHash value, then that is what will be instantiated, spawned, and returned.
         /// </summary>
-        internal NetworkObject GetNetworkObjectToSpawn<T>(uint globalObjectIdHash, ulong ownerId, ref BufferSerializer<T> instantiationPayloadSerializer, Vector3? position, Quaternion? rotation, bool isScenePlaced = false) where T : IReaderWriter
+        internal NetworkObject GetNetworkObjectToSpawn(uint globalObjectIdHash, ulong ownerId, Vector3? position, Quaternion? rotation, bool isScenePlaced = false)
         {
             NetworkObject networkObject = null;
             // If the prefab hash has a registered INetworkPrefabInstanceHandler derived class
             if (NetworkManager.PrefabHandler.ContainsHandler(globalObjectIdHash))
             {
                 // Let the handler spawn the NetworkObject
-                networkObject = NetworkManager.PrefabHandler.HandleNetworkPrefabSpawn(globalObjectIdHash, ownerId, ref instantiationPayloadSerializer, position ?? default, rotation ?? default);
+                networkObject = NetworkManager.PrefabHandler.HandleNetworkPrefabSpawn(globalObjectIdHash, ownerId, position ?? default, rotation ?? default);
                 networkObject.NetworkManagerOwner = NetworkManager;
             }
             else
@@ -889,8 +889,7 @@ internal NetworkObject CreateLocalNetworkObject(NetworkObject.SceneObject sceneO
             // If scene management is disabled or the NetworkObject was dynamically spawned
             if (!NetworkManager.NetworkConfig.EnableSceneManagement || !sceneObject.IsSceneObject)
             {
-                var instantiationPayloadReader = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(sceneObject.InstantiationPayload));
-                networkObject = GetNetworkObjectToSpawn(sceneObject.Hash, sceneObject.OwnerClientId, ref instantiationPayloadReader, position, rotation, sceneObject.IsSceneObject);
+                networkObject = GetNetworkObjectToSpawn(sceneObject.Hash, sceneObject.OwnerClientId, position, rotation, sceneObject.IsSceneObject);
             }
             else // Get the in-scene placed NetworkObject
             {