feat: RPC Network Update Order and Network Update Loop Registration

com.unity.multiplayer.mlapi/Runtime/Core/MessageBatcher.cs

@@ -2,6 +2,7 @@
 using MLAPI.Serialization;
 using MLAPI.Configuration;
 using MLAPI.Profiling;
+using MLAPI.Messaging;
 using System.Collections.Generic;
 using System.Linq;
 using System;
@@ -15,12 +16,17 @@ public class SendStream
         {
             public string channel;
             public PooledBitStream Stream = PooledBitStream.Get();
+            public PooledBitWriter Writer;
             public bool Empty = true;
+
+            public SendStream()
+            {
+                Writer = PooledBitWriter.Get(Stream);
+            }
         }
 
         // Stores the stream of batched RPC to send to each client, by ClientId
         private Dictionary<ulong, SendStream> SendDict = new Dictionary<ulong, SendStream>();
-        private PooledBitWriter Writer = new PooledBitWriter(PooledBitStream.Get());
 
         // Used to store targets, internally
         private ulong[] TargetList = new ulong[0];
@@ -115,37 +121,35 @@ public void QueueItem(in FrameQueueItem item)
                 {
                     SendDict[clientId].Empty = false;
                     SendDict[clientId].channel = item.channel;
-                    Writer.SetStream(SendDict[clientId].Stream);
 
-                    Writer.WriteBit(false); // Encrypted
-                    Writer.WriteBit(false); // Authenticated
+                    SendDict[clientId].Writer.WriteBit(false); // Encrypted
+                    SendDict[clientId].Writer.WriteBit(false); // Authenticated
 
                     switch (item.queueItemType)
                     {
                         // 6 bits are used for the message type, which is an MLAPIConstants
                         case RpcQueueContainer.QueueItemType.ServerRpc:
-                            Writer.WriteBits(MLAPIConstants.MLAPI_SERVER_RPC, 6); // MessageType
+                            SendDict[clientId].Writer.WriteBits(MLAPIConstants.MLAPI_SERVER_RPC, 6); // MessageType
                             break;
                         case RpcQueueContainer.QueueItemType.ClientRpc:
-                            Writer.WriteBits(MLAPIConstants.MLAPI_CLIENT_RPC, 6); // MessageType
+                            SendDict[clientId].Writer.WriteBits(MLAPIConstants.MLAPI_CLIENT_RPC, 6); // MessageType
                             break;
                     }
                 }
 
                 // write the amounts of bytes that are coming up
-                PushLength(item.messageData.Count, ref Writer);
+                PushLength(item.messageData.Count, ref SendDict[clientId].Writer);
 
                 // write the message to send
-                // todo: is there a faster alternative to .ToArray()
-                Writer.WriteBytes(item.messageData.ToArray(), item.messageData.Count);
+                SendDict[clientId].Writer.WriteBytes(item.messageData.Array, item.messageData.Count, item.messageData.Offset);
 
                 ProfilerStatManager.bytesSent.Record((int)item.messageData.Count);
                 ProfilerStatManager.rpcsSent.Record();
             }
         }
 
         public delegate void SendCallbackType(ulong clientId, SendStream messageStream);
-        public delegate void ReceiveCallbackType(BitStream messageStream, MLAPI.RpcQueueContainer.QueueItemType messageType, ulong clientId, float time);
+        public delegate void ReceiveCallbackType(BitStream messageStream, RpcQueueContainer.QueueItemType messageType, ulong clientId, float time);
 
         /// <summary>
         /// SendItems
@@ -165,17 +169,17 @@ public void SendItems(int threshold, SendCallbackType sendCallback)
                     if (length >= threshold)
                     {
                         sendCallback(entry.Key, entry.Value);
-                        ProfilerStatManager.rpcBatchesSent.Record();
-
                         // clear the batch that was sent from the SendDict
                         entry.Value.Stream.SetLength(0);
                         entry.Value.Stream.Position = 0;
                         entry.Value.Empty = true;
+                        ProfilerStatManager.rpcBatchesSent.Record();
                     }
                 }
             }
         }
 
+
         /// <summary>
         /// ReceiveItems
         /// Process the messageStream and call the callback with individual RPC messages
@@ -185,7 +189,7 @@ public void SendItems(int threshold, SendCallbackType sendCallback)
         /// <param name="messageType"> the message type to pass back to callback</param>
         /// <param name="clientId"> the clientId to pass back to callback</param>
         /// <param name="receiveTime"> the packet receive time to pass back to callback</param>
-        public int ReceiveItems(in BitStream messageStream, ReceiveCallbackType receiveCallback, MLAPI.RpcQueueContainer.QueueItemType messageType, ulong clientId, float receiveTime)
+        public int ReceiveItems(in BitStream messageStream, ReceiveCallbackType receiveCallback, RpcQueueContainer.QueueItemType messageType, ulong clientId, float receiveTime)
         {
             using PooledBitStream copy = PooledBitStream.Get();
             do
@@ -195,6 +199,7 @@ public int ReceiveItems(in BitStream messageStream, ReceiveCallbackType receiveC
 
                 if (rpcSize < 0)
                 {
+                    copy.Dispose();
                     // abort if there's an error reading lengths
                     return 0;
                 }
@@ -211,6 +216,7 @@ public int ReceiveItems(in BitStream messageStream, ReceiveCallbackType receiveC
                 // RPCReceiveQueueItem peeks at content, it doesn't advance
                 messageStream.Seek(rpcSize, SeekOrigin.Current);
             } while (messageStream.Position < messageStream.Length);
+            copy.Dispose();
             return 0;
         }
     }

com.unity.multiplayer.mlapi/Runtime/Core/NetworkUpdateLoopSystem.cs

@@ -0,0 +1,129 @@
+using System;
+using UnityEngine;
+
+
+namespace MLAPI
+{
+    /// <summary>
+    ///  NetworkUpdateLoopBehaviour
+    ///  Derive from this class if you need to register a NetworkedBehaviour based class
+    /// </summary>
+    public class NetworkUpdateLoopBehaviour:NetworkedBehaviour,INetworkUpdateLoopSystem
+    {
+        protected virtual Action InternalRegisterNetworkUpdateStage(NetworkUpdateManager.NetworkUpdateStages stage )
+        {
+            return null;
+        }
+
+        public Action RegisterUpdate(NetworkUpdateManager.NetworkUpdateStages stage )
+        {
+            return InternalRegisterNetworkUpdateStage(stage);
+        }
+
+        protected void RegisterUpdateLoopSystem()
+        {
+            NetworkUpdateManager.NetworkLoopRegistration(this);
+        }
+
+        protected void OnNetworkLoopSystemRemove()
+        {
+            if(onNetworkLoopSystemDestroyed != null)
+            {
+                onNetworkLoopSystemDestroyed.Invoke(this);
+            }
+        }
+
+        Action<INetworkUpdateLoopSystem> onNetworkLoopSystemDestroyed;
+
+        public void RegisterUpdateLoopSystemDestroyCallback(Action<INetworkUpdateLoopSystem> networkLoopSystemDestroyedCallback)
+        {
+            onNetworkLoopSystemDestroyed = networkLoopSystemDestroyedCallback;
+        }
+    }
+
+    /// <summary>
+    ///  UpdateLoopBehaviour
+    ///  Derive from this class if you only require MonoBehaviour functionality
+    /// </summary>
+    public class UpdateLoopBehaviour:MonoBehaviour,INetworkUpdateLoopSystem
+    {
+        protected virtual Action InternalRegisterNetworkUpdateStage(NetworkUpdateManager.NetworkUpdateStages stage )
+        {
+            return null;
+        }
+
+        public Action RegisterUpdate(NetworkUpdateManager.NetworkUpdateStages stage )
+        {
+            return InternalRegisterNetworkUpdateStage(stage);
+        }
+
+        protected void RegisterUpdateLoopSystem()
+        {
+            NetworkUpdateManager.NetworkLoopRegistration(this);
+        }
+
+        protected void OnNetworkLoopSystemRemove()
+        {
+            if(onNetworkLoopSystemDestroyed != null)
+            {
+                onNetworkLoopSystemDestroyed.Invoke(this);
+            }
+        }
+
+        Action<INetworkUpdateLoopSystem> onNetworkLoopSystemDestroyed;
+
+        public void RegisterUpdateLoopSystemDestroyCallback(Action<INetworkUpdateLoopSystem> networkLoopSystemDestroyedCallback)
+        {
+            onNetworkLoopSystemDestroyed = networkLoopSystemDestroyedCallback;
+        }
+    }
+
+    /// <summary>
+    /// GenericUpdateLoopSystem
+    /// Derive from this class for generic (non-MonoBehaviour) classes
+    /// </summary>
+    public class GenericUpdateLoopSystem:INetworkUpdateLoopSystem
+    {
+        protected virtual Action InternalRegisterNetworkUpdateStage(NetworkUpdateManager.NetworkUpdateStages stage )
+        {
+            return null;
+        }
+
+        public Action RegisterUpdate(NetworkUpdateManager.NetworkUpdateStages stage )
+        {
+            return InternalRegisterNetworkUpdateStage(stage);
+        }
+
+        protected void RegisterUpdateLoopSystem()
+        {
+            NetworkUpdateManager.NetworkLoopRegistration(this);
+        }
+
+        protected void OnNetworkLoopSystemRemove()
+        {
+            if(onNetworkLoopSystemDestroyed != null)
+            {
+                onNetworkLoopSystemDestroyed.Invoke(this);
+            }
+        }
+
+        Action<INetworkUpdateLoopSystem> onNetworkLoopSystemDestroyed;
+
+        public void RegisterUpdateLoopSystemDestroyCallback(Action<INetworkUpdateLoopSystem> networkLoopSystemDestroyedCallback)
+        {
+            onNetworkLoopSystemDestroyed = networkLoopSystemDestroyedCallback;
+        }
+    }
+
+
+    /// <summary>
+    /// INetworkUpdateLoopSystem
+    /// Use this interface if you need a custom class beyond the scope of GenericUpdateLoopSystem, UpdateLoopBehaviour, and NetworkUpdateLoopBehaviour
+    /// </summary>
+    public interface INetworkUpdateLoopSystem
+    {
+        Action RegisterUpdate(NetworkUpdateManager.NetworkUpdateStages stage );
+
+        void RegisterUpdateLoopSystemDestroyCallback(Action<INetworkUpdateLoopSystem>  networkLoopSystemDestroyedCallbsack);
+    }
+}