Unity-Technologies · NoelStephensUnity · Apr 28, 2021 · Apr 16, 2021 · Apr 16, 2021 · Apr 16, 2021
@@ -1600,51 +1600,7 @@ internal void HandleApproval(ulong ownerClientId, bool createPlayerObject, uint?
 
                         for (int i = 0; i < m_ObservedObjects.Count; i++)
                         {
-                            var observedObject = m_ObservedObjects[i];
-                            writer.WriteBool(observedObject.IsPlayerObject);
-                            writer.WriteUInt64Packed(observedObject.NetworkObjectId);
-                            writer.WriteUInt64Packed(observedObject.OwnerClientId);
-
-                            NetworkObject parent = null;
-
-                            if (!observedObject.AlwaysReplicateAsRoot && observedObject.transform.parent != null)
-                            {
-                                parent = observedObject.transform.parent.GetComponent<NetworkObject>();
-                            }
-
-                            if (parent == null)
-                            {
-                                writer.WriteBool(false);
-                            }
-                            else
-                            {
-                                writer.WriteBool(true);
-                                writer.WriteUInt64Packed(parent.NetworkObjectId);
-                            }
-
-                            writer.WriteBool(observedObject.IsSceneObject ?? true);
-                            writer.WriteUInt32Packed(observedObject.GlobalObjectIdHash);
-
-                            if (observedObject.IncludeTransformWhenSpawning == null || observedObject.IncludeTransformWhenSpawning(ownerClientId))
-                            {
-                                writer.WriteBool(true);
-                                writer.WriteSinglePacked(observedObject.transform.position.x);
-                                writer.WriteSinglePacked(observedObject.transform.position.y);
-                                writer.WriteSinglePacked(observedObject.transform.position.z);
-
-                                writer.WriteSinglePacked(observedObject.transform.rotation.eulerAngles.x);
-                                writer.WriteSinglePacked(observedObject.transform.rotation.eulerAngles.y);
-                                writer.WriteSinglePacked(observedObject.transform.rotation.eulerAngles.z);
-                            }
-                            else
-                            {
-                                writer.WriteBool(false);
-                            }
-
-                            if (NetworkConfig.EnableNetworkVariable)
-                            {
-                                observedObject.WriteNetworkVariableData(buffer, ownerClientId);
-                            }
+                            m_ObservedObjects[i].SerializeSceneObject(writer, ownerClientId);
                         }
 
                         MessageSender.Send(ownerClientId, NetworkConstants.CONNECTION_APPROVED, NetworkChannel.Internal, buffer);

@@ -8,6 +8,7 @@
 using MLAPI.Logging;
 using MLAPI.Serialization.Pooled;
 using MLAPI.Transports;
+using MLAPI.Serialization;
 using UnityEngine;
 
 namespace MLAPI
@@ -598,5 +599,185 @@ internal NetworkBehaviour GetNetworkBehaviourAtOrderIndex(ushort index)
 
             return ChildNetworkBehaviours[index];
         }
+
+        /// <summary>
+        /// Used to serialize a NetworkObjects during scene syncrhonization that occurs
+        /// upon a client being approved or a scene transition.
+        /// </summary>
+        /// <param name="writer">writer into the outbound stream</param>
+        /// <param name="targetClientId">clientid we are targeting</param>
+        internal void SerializeSceneObject(NetworkWriter writer, ulong targetClientId)
+        {
+            writer.WriteBool(IsPlayerObject);
+            writer.WriteUInt64Packed(NetworkObjectId);
+            writer.WriteUInt64Packed(OwnerClientId);
+
+            NetworkObject parentNetworkObject = null;
+
+            if (!AlwaysReplicateAsRoot && transform.parent != null)
+            {
+                parentNetworkObject = transform.parent.GetComponent<NetworkObject>();
+            }
+
+            if (parentNetworkObject == null)
+            {
+                // We don't have a parent
+                writer.WriteBool(false);
+            }
+            else
+            {
+                // We do have a parent
+                writer.WriteBool(true);
+                // Write the parent's NetworkObjectId to be used for linking back to the child
+                writer.WriteUInt64Packed(parentNetworkObject.NetworkObjectId);
+            }
+
+            // Write if we are a scene object or not
+            writer.WriteBool(IsSceneObject ?? true);
+
+            // Write the hash for this NetworkObject
+            writer.WriteUInt32Packed(GlobalObjectIdHash);
+
+            if (IncludeTransformWhenSpawning == null || IncludeTransformWhenSpawning(OwnerClientId))
+            {
+                // Set the position and rotation data marker to true (i.e. flag to know, when reading from the stream, that position and rotation data follows).
+                writer.WriteBool(true);
+
+                // Write position
+                writer.WriteSinglePacked(transform.position.x);
+                writer.WriteSinglePacked(transform.position.y);
+                writer.WriteSinglePacked(transform.position.z);
+
+                // Write rotation
+                writer.WriteSinglePacked(transform.rotation.eulerAngles.x);
+                writer.WriteSinglePacked(transform.rotation.eulerAngles.y);
+                writer.WriteSinglePacked(transform.rotation.eulerAngles.z);
+            }
+            else
+            {
+                // Set the position and rotation data marker to false (i.e. flag to know, when reading from the stream, that position and rotation data *was not included*)
+                writer.WriteBool(false);
+            }
+
+            // Write whether we are including network variable data
+            writer.WriteBool(NetworkManager.NetworkConfig.EnableNetworkVariable);
+
+            //If we are including NetworkVariable data
+            if (NetworkManager.NetworkConfig.EnableNetworkVariable)
+            {
+                var buffer = writer.GetStream() as NetworkBuffer;
+
+                // Write placeholder size, NOT as a packed value, initially as zero (i.e. we do not know how much NetworkVariable data will be written yet)
+                writer.WriteUInt32(0);
+
+                // Mark our current position before we potentially write any NetworkVariable data 
+                var positionBeforeNetworkVariableData = buffer.Position;
+
+                // Write network variable data 
+                WriteNetworkVariableData(buffer, targetClientId);
+
+                // If our current buffer position is greater than our positionBeforeNetworkVariableData then we wrote NetworkVariable data
+                // Part 1: This will include the total NetworkVariable data size, if there was NetworkVariable data written, to the stream
+                // in order to be able to skip past this entry on the de-serialization side in the event this NetworkObject fails to be
+                // constructed (See Part 2 below in the DeserializeSceneObject method) 
+                if (buffer.Position > positionBeforeNetworkVariableData)
+                {
+                    // Store our current stream buffer position 
+                    var endOfNetworkVariableData = buffer.Position;
+
+                    // Calculate the total NetworkVariable data size written        
+                    var networkVariableDataSize = endOfNetworkVariableData - positionBeforeNetworkVariableData;
+
+                    // Move the stream position back to just before we wrote our size (we include the unpacked UInt32 data size placeholder)
+                    buffer.Position = positionBeforeNetworkVariableData - sizeof(uint);
+
+                    // Now write the actual data size written into our unpacked UInt32 placeholder position
+                    writer.WriteUInt32((uint)(networkVariableDataSize));
+
+                    // Finally, revert the buffer position back to the end of the network variable data written
+                    buffer.Position = endOfNetworkVariableData;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Ueed to deserialize a serialized scene object which occurs
+        /// when the client is approved or during a scene transition
+        /// </summary>
+        /// <param name="objectStream">inbound stream</param>
+        /// <param name="reader">reader for the stream</param>
+        /// <param name="networkManager">NetworkManager instance</param>
+        /// <returns>optional to use NetworkObject deserialized</returns>
+        internal static NetworkObject DeserializeSceneObject(NetworkBuffer objectStream, NetworkReader reader, NetworkManager networkManager)
+        {
+            var isPlayerObject = reader.ReadBool();
+            var networkId = reader.ReadUInt64Packed();
+            var ownerClientId = reader.ReadUInt64Packed();
+            var hasParent = reader.ReadBool();
+            ulong? parentNetworkId = null;
+
+            if (hasParent)
+            {
+                parentNetworkId = reader.ReadUInt32Packed();
+            }
+
+            var isSceneObject = reader.ReadBool();
+
+            var prefabHash = reader.ReadUInt32Packed();
+            Vector3? position = null;
+            Quaternion? rotation = null;
+
+            // Check to see if we have position and rotation values that follows
+            if (reader.ReadBool())
+            {
+                position = new Vector3(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
+                rotation = Quaternion.Euler(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
+            }
+
+            //Attemp to create a local NetworkObject
+            var networkObject = networkManager.SpawnManager.CreateLocalNetworkObject(isSceneObject, prefabHash, ownerClientId, parentNetworkId, position, rotation);
+
+            // Determine if this NetworkObject has NetworkVariable data to read
+            var networkVariableDataIsIncluded = reader.ReadBool();
+
+            if (networkVariableDataIsIncluded)
+            {
+                // (See Part 1 above in the NetworkObject.SerializeSceneObject method to better understand this) 
+                // Part 2: This makes sure that if one NetworkObject fails to construct (for whatever reason) then we can "skip past"
+                // that specific NetworkObject but continue processing any remaining serialized NetworkObjects as opposed to just
+                // throwing an exception and skipping the remaining (if any) NetworkObjects.  This will prevent one misconfigured
+                // issue (or more) from breaking the entire loading process.
+                var networkVariableDataSize = reader.ReadUInt32();
+                if (networkObject == null)
+                {
+                    // Log the error that the NetworkObject failed to construct
+                    Debug.LogError($"Failed to spawn {nameof(NetworkObject)} for Hash {prefabHash}.");
+
+                    // If we failed to load this NetworkObject, then skip past the network variable data
+                    objectStream.Position += networkVariableDataSize;
+
+                    // We have nothing left to do here.
+                    return null;
+                }
+            }
+
+            // Spawn the NetworkObject
+            networkManager.SpawnManager.SpawnNetworkObjectLocally(networkObject, networkId, isSceneObject, isPlayerObject, ownerClientId, objectStream, false, 0, true, false);
+
+            var bufferQueue = networkManager.BufferManager.ConsumeBuffersForNetworkId(networkId);
+
+            // Apply buffered messages
+            if (bufferQueue != null)
+            {
+                while (bufferQueue.Count > 0)
+                {
+                    Messaging.Buffering.BufferManager.BufferedMessage message = bufferQueue.Dequeue();
+                    networkManager.HandleIncomingData(message.SenderClientId, message.NetworkChannel, new ArraySegment<byte>(message.NetworkBuffer.GetBuffer(), (int)message.NetworkBuffer.Position, (int)message.NetworkBuffer.Length), message.ReceiveTime, false);
+                    Messaging.Buffering.BufferManager.RecycleConsumedBufferedMessage(message);
+                }
+            }
+
+            return networkObject;
+        }
     }
 }
@@ -131,43 +131,7 @@ void DelayedSpawnAction(Stream continuationStream)
                         var objectCount = continuationReader.ReadUInt32Packed();
                         for (int i = 0; i < objectCount; i++)
                         {
-                            var isPlayerObject = continuationReader.ReadBool();
-                            var networkId = continuationReader.ReadUInt64Packed();
-                            var ownerId = continuationReader.ReadUInt64Packed();
-                            var hasParent = continuationReader.ReadBool();
-                            ulong? parentNetworkId = null;
-
-                            if (hasParent)
-                            {
-                                parentNetworkId = continuationReader.ReadUInt64Packed();
-                            }
-
-                            var softSync = continuationReader.ReadBool();
-                            var prefabHash = continuationReader.ReadUInt32Packed();
-
-                            Vector3? pos = null;
-                            Quaternion? rot = null;
-                            if (continuationReader.ReadBool())
-                            {
-                                pos = new Vector3(continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked());
-                                rot = Quaternion.Euler(continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked());
-                            }
-
-                            var networkObject = NetworkManager.SpawnManager.CreateLocalNetworkObject(softSync, prefabHash, ownerId, parentNetworkId, pos, rot);
-                            NetworkManager.SpawnManager.SpawnNetworkObjectLocally(networkObject, networkId, softSync, isPlayerObject, ownerId, continuationStream, false, 0, true, false);
-
-                            Queue<BufferManager.BufferedMessage> bufferQueue = NetworkManager.BufferManager.ConsumeBuffersForNetworkId(networkId);
-
-                            // Apply buffered messages
-                            if (bufferQueue != null)
-                            {
-                                while (bufferQueue.Count > 0)
-                                {
-                                    BufferManager.BufferedMessage message = bufferQueue.Dequeue();
-                                    NetworkManager.HandleIncomingData(message.SenderClientId, message.NetworkChannel, new ArraySegment<byte>(message.NetworkBuffer.GetBuffer(), (int)message.NetworkBuffer.Position, (int)message.NetworkBuffer.Length), message.ReceiveTime, false);
-                                    BufferManager.RecycleConsumedBufferedMessage(message);
-                                }
-                            }
+                            NetworkObject.DeserializeSceneObject(continuationStream as NetworkBuffer, continuationReader, m_NetworkManager);
                         }
 
                         NetworkManager.SpawnManager.CleanDiffedSceneObjects();