Pure stateless, non generic approach for sending data through fastBufferReader

Author: Extrys

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

@@ -3239,13 +3239,10 @@ internal static NetworkObject AddSceneObject(in SceneObject sceneObject, FastBuf
             var bufferSerializer = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(reader));
 
             //Synchronize the instantiation data if needed
-            if (sceneObject.HasInstantiationData)
-            {
-                networkManager.PrefabHandler.ReadInstantiationData(sceneObject.Hash, ref bufferSerializer);
-            }
+            FastBufferReader instantiationDataReader = sceneObject.HasInstantiationData ? networkManager.PrefabHandler.GetInstantiationDataReader(sceneObject.Hash, ref bufferSerializer) : default;
 
             //Attempt to create a local NetworkObject
-            var networkObject = networkManager.SpawnManager.CreateLocalNetworkObject(sceneObject);
+            var networkObject = networkManager.SpawnManager.CreateLocalNetworkObject(sceneObject, instantiationDataReader);
 
             if (networkObject == null)
             {

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

@@ -17,35 +17,25 @@ public interface INetworkPrefabInstanceHandlerWithData<T> where T : struct, INet
 
     internal interface INetworkPrefabInstanceHandlerWithData : INetworkPrefabInstanceHandler
     {
+        NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation, FastBufferReader reader);
         bool HandlesDataType<T>();
-        void ReadInstantiationData<TReaderWriter>(ref BufferSerializer<TReaderWriter> serializer) where TReaderWriter : IReaderWriter;
     }
 
     internal class HandlerWrapper<T> : INetworkPrefabInstanceHandlerWithData where T : struct, INetworkSerializable
     {
         private readonly INetworkPrefabInstanceHandlerWithData<T> _impl;
-        private T _payload;
-
+        
         public HandlerWrapper(INetworkPrefabInstanceHandlerWithData<T> impl) => _impl = impl;
-        public bool HandlesDataType<U>() => typeof(T) == typeof(U);
-        public void ReadInstantiationData<TReaderWriter>(ref BufferSerializer<TReaderWriter> serializer) where TReaderWriter : IReaderWriter => serializer.SerializeValue(ref _payload);
-        public NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation) => _impl.Instantiate(ownerClientId, position, rotation, _payload);
-        public void Destroy(NetworkObject networkObject) => _impl.Destroy(networkObject);
-    }
 
+        public bool HandlesDataType<U>() => typeof(T) == typeof(U);
 
-    public static class INetworkPrefabInstanceHandlerWithDataExtensions
-    {
-        /// PLACEHOLDER: If this pattern is liked, i can move all the injection code to here instead of the PrefabHandler
-        public static void InjectInstantiationData<T>(this INetworkPrefabInstanceHandlerWithData<T> handler, NetworkObject networkObject, T data) where T : struct, INetworkSerializable
+        public NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation, FastBufferReader reader)
         {
-            NetworkManager.Singleton.PrefabHandler.InjectInstantiationData(networkObject, data);
+            reader.ReadValueSafe(out T _payload);
+            return _impl.Instantiate(ownerClientId, position, rotation, _payload);
         }
 
-        public static void SpawnWithData<T>(this INetworkPrefabInstanceHandlerWithData<T> handler, NetworkObject networkObject, T data) where T : struct, INetworkSerializable
-        {
-            InjectInstantiationData(handler, networkObject, data);
-            networkObject.Spawn();
-        }
+        public NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation) => _impl.Instantiate(ownerClientId, position, rotation, default);
+        public void Destroy(NetworkObject networkObject) => _impl.Destroy(networkObject);
     }
 }

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

@@ -297,37 +297,20 @@ internal bool TryGetHandlerWithData(uint objectHash, out INetworkPrefabInstanceH
         /// <typeparam name="T"></typeparam>
         /// <param name="objectHash"></param>
         /// <param name="serializer"></param>
-        internal void ReadInstantiationData<T>(uint objectHash, ref BufferSerializer<T> serializer) where T : IReaderWriter
+        internal FastBufferReader GetInstantiationDataReader<T>(uint objectHash, ref BufferSerializer<T> serializer) where T : IReaderWriter
         {
             if (!serializer.IsReader || !TryGetHandlerWithData(objectHash, out INetworkPrefabInstanceHandlerWithData synchronizableHandler))
             {
-                return;
+                return default;
             }
 
             FastBufferReader fastBufferReader = serializer.GetFastBufferReader();
             // Reads the expected size of the instantiation data
             fastBufferReader.ReadValueSafe(out int dataSize);
             int dataStartPos = fastBufferReader.Position;
-
-            try
-            {
-                synchronizableHandler.ReadInstantiationData(ref serializer);
-            }
-            catch (Exception ex)
-            {
-                // 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 dataEndPos = fastBufferReader.Position;
-            if (dataEndPos != dataStartPos + dataSize)
-            {
-                NetworkLog.LogWarning($"[InstantiationData] Read {dataEndPos - dataStartPos} bytes, expected {dataSize}");
-                fastBufferReader.Seek(dataStartPos + dataSize);
-            }
+            var result = new FastBufferReader(fastBufferReader, Collections.Allocator.Temp, dataSize, dataStartPos);
+            fastBufferReader.Seek(dataStartPos + dataSize);
+            return result;
         }
 
         /// <summary>
@@ -359,23 +342,38 @@ internal uint GetSourceGlobalObjectIdHash(uint networkPrefabHash)
         /// <param name="position"></param>
         /// <param name="rotation"></param>
         /// <returns></returns>
-        internal NetworkObject HandleNetworkPrefabSpawn(uint networkPrefabAssetHash, ulong ownerClientId, Vector3 position, Quaternion rotation)
+        internal NetworkObject HandleNetworkPrefabSpawn(uint networkPrefabAssetHash, ulong ownerClientId, Vector3 position, Quaternion rotation, FastBufferReader instantiationDataReader = default)
+        {
+            NetworkObject networkObjectInstance = instantiationDataReader.IsInitialized
+                ? InstantiateNetworkPrefabWithData(networkPrefabAssetHash, ownerClientId, position, rotation, instantiationDataReader)
+                : InstantiateNetworkPrefabDefault(networkPrefabAssetHash, ownerClientId, position, rotation);
+            //Now we must make sure this alternate PrefabAsset spawned in place of the prefab asset with the networkPrefabAssetHash (GlobalObjectIdHash)
+            //is registered and linked to the networkPrefabAssetHash so during the HandleNetworkPrefabDestroy process we can identify the alternate prefab asset.
+            if (networkObjectInstance != null)
+                RegisterPrefabInstance(networkObjectInstance, networkPrefabAssetHash);
+            return networkObjectInstance;
+        }
+
+        private NetworkObject InstantiateNetworkPrefabDefault(uint networkPrefabAssetHash, ulong ownerClientId, Vector3 position, Quaternion rotation)
         {
             if (m_PrefabAssetToPrefabHandler.TryGetValue(networkPrefabAssetHash, out var prefabInstanceHandler))
-            {
-                var networkObjectInstance = prefabInstanceHandler.Instantiate(ownerClientId, position, rotation);
+                return prefabInstanceHandler.Instantiate(ownerClientId, position, rotation);
+            return null;
+        }
 
-                //Now we must make sure this alternate PrefabAsset spawned in place of the prefab asset with the networkPrefabAssetHash (GlobalObjectIdHash)
-                //is registered and linked to the networkPrefabAssetHash so during the HandleNetworkPrefabDestroy process we can identify the alternate prefab asset.
-                if (networkObjectInstance != null && !m_PrefabInstanceToPrefabAsset.ContainsKey(networkObjectInstance.GlobalObjectIdHash))
-                {
-                    m_PrefabInstanceToPrefabAsset.Add(networkObjectInstance.GlobalObjectIdHash, networkPrefabAssetHash);
-                }
+        private NetworkObject InstantiateNetworkPrefabWithData(uint networkPrefabAssetHash, ulong ownerClientId, Vector3 position, Quaternion rotation, FastBufferReader instantiationDataReader)
+        {
+            if (m_PrefabAssetToPrefabHandlerWithData.TryGetValue(networkPrefabAssetHash, out var prefabInstanceHandler))
+                return prefabInstanceHandler.Instantiate(ownerClientId, position, rotation, instantiationDataReader);
+            return null;
+        }
 
-                return networkObjectInstance;
+        private void RegisterPrefabInstance(NetworkObject networkObjectInstance, uint networkPrefabAssetHash)
+        {
+            if (networkObjectInstance != null && !m_PrefabInstanceToPrefabAsset.ContainsKey(networkObjectInstance.GlobalObjectIdHash))
+            {
+                m_PrefabInstanceToPrefabAsset.Add(networkObjectInstance.GlobalObjectIdHash, networkPrefabAssetHash);
             }
-
-            return null;
         }
 
         /// <summary>

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

@@ -779,14 +779,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(uint globalObjectIdHash, ulong ownerId, Vector3? position, Quaternion? rotation, bool isScenePlaced = false)
+        internal NetworkObject GetNetworkObjectToSpawn(uint globalObjectIdHash, ulong ownerId, Vector3? position, Quaternion? rotation, bool isScenePlaced = false, FastBufferReader instantiationDataReader = default)
         {
             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, position ?? default, rotation ?? default);
+                networkObject = NetworkManager.PrefabHandler.HandleNetworkPrefabSpawn(globalObjectIdHash, ownerId, position ?? default, rotation ?? default, instantiationDataReader);
                 networkObject.NetworkManagerOwner = NetworkManager;
             }
             else
@@ -807,22 +807,22 @@ internal NetworkObject GetNetworkObjectToSpawn(uint globalObjectIdHash, ulong ow
                             break;
                         case NetworkPrefabOverride.Hash:
                         case NetworkPrefabOverride.Prefab:
+                        {
+                            // When scene management is disabled and this is an in-scene placed NetworkObject, we want to always use the
+                            // SourcePrefabToOverride and not any possible prefab override as a user might want to spawn overrides dynamically
+                            // but might want to use the same source network prefab as an in-scene placed NetworkObject.
+                            // (When scene management is enabled, clients don't delete their in-scene placed NetworkObjects prior to dynamically
+                            // spawning them so the original prefab placed is preserved and this is not needed)
+                            if (inScenePlacedWithNoSceneManagement)
                             {
-                                // When scene management is disabled and this is an in-scene placed NetworkObject, we want to always use the
-                                // SourcePrefabToOverride and not any possible prefab override as a user might want to spawn overrides dynamically
-                                // but might want to use the same source network prefab as an in-scene placed NetworkObject.
-                                // (When scene management is enabled, clients don't delete their in-scene placed NetworkObjects prior to dynamically
-                                // spawning them so the original prefab placed is preserved and this is not needed)
-                                if (inScenePlacedWithNoSceneManagement)
-                                {
-                                    networkPrefabReference = networkPrefab.SourcePrefabToOverride ? networkPrefab.SourcePrefabToOverride : networkPrefab.Prefab;
-                                }
-                                else
-                                {
-                                    networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab;
-                                }
-                                break;
+                                networkPrefabReference = networkPrefab.SourcePrefabToOverride ? networkPrefab.SourcePrefabToOverride : networkPrefab.Prefab;
                             }
+                            else
+                            {
+                                networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab;
+                            }
+                            break;
+                        }
                     }
                 }
 
@@ -875,7 +875,7 @@ internal NetworkObject InstantiateNetworkPrefab(GameObject networkPrefab, uint p
         /// For most cases this is client-side only, with the exception of when the server
         /// is spawning a player.
         /// </remarks>
-        internal NetworkObject CreateLocalNetworkObject(NetworkObject.SceneObject sceneObject)
+        internal NetworkObject CreateLocalNetworkObject(NetworkObject.SceneObject sceneObject, FastBufferReader instantiationDataReader = default)
         {
             NetworkObject networkObject = null;
             var globalObjectIdHash = sceneObject.Hash;
@@ -888,7 +888,7 @@ internal NetworkObject CreateLocalNetworkObject(NetworkObject.SceneObject sceneO
             // If scene management is disabled or the NetworkObject was dynamically spawned
             if (!NetworkManager.NetworkConfig.EnableSceneManagement || !sceneObject.IsSceneObject)
             {
-                networkObject = GetNetworkObjectToSpawn(sceneObject.Hash, sceneObject.OwnerClientId, position, rotation, sceneObject.IsSceneObject);
+                networkObject = GetNetworkObjectToSpawn(sceneObject.Hash, sceneObject.OwnerClientId, position, rotation, sceneObject.IsSceneObject, instantiationDataReader);
             }
             else // Get the in-scene placed NetworkObject
             {