refactor: rpcqueue

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

@@ -78,15 +78,15 @@ private int PopLength(in BitStream messageStream)
         /// <param name="list">the list to fill</param>
         private static void FillTargetList(in FrameQueueItem item, ref ulong[] list)
         {
-            switch (item.QueueItemType)
+            switch (item.queueItemType)
             {
-                case RPCQueueManager.QueueItemType.ServerRpc:
+                case RpcQueueContainer.QueueItemType.ServerRpc:
                     Array.Resize(ref list, 1);
-                    list[0] = item.NetworkId;
+                    list[0] = item.networkId;
                     break;
-                case RPCQueueManager.QueueItemType.ClientRpc:
+                case RpcQueueContainer.QueueItemType.ClientRpc:
                     // copy the list
-                    list = item.ClientIds.ToArray();
+                    list = item.clientIds.ToArray();
                     break;
                 default:
                     break;
@@ -114,38 +114,38 @@ public void QueueItem(in FrameQueueItem item)
                 if (SendDict[clientId].Empty)
                 {
                     SendDict[clientId].Empty = false;
-                    SendDict[clientId].channel = item.Channel;
+                    SendDict[clientId].channel = item.channel;
                     Writer.SetStream(SendDict[clientId].Stream);
 
                     Writer.WriteBit(false); // Encrypted
                     Writer.WriteBit(false); // Authenticated
 
-                    switch (item.QueueItemType)
+                    switch (item.queueItemType)
                     {
                         // 6 bits are used for the message type, which is an MLAPIConstants
-                        case RPCQueueManager.QueueItemType.ServerRpc:
+                        case RpcQueueContainer.QueueItemType.ServerRpc:
                             Writer.WriteBits(MLAPIConstants.MLAPI_SERVER_RPC, 6); // MessageType
                             break;
-                        case RPCQueueManager.QueueItemType.ClientRpc:
+                        case RpcQueueContainer.QueueItemType.ClientRpc:
                             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 Writer);
 
                 // write the message to send
                 // todo: is there a faster alternative to .ToArray()
-                Writer.WriteBytes(item.MessageData.ToArray(), item.MessageData.Count);
+                Writer.WriteBytes(item.messageData.ToArray(), item.messageData.Count);
 
-                ProfilerStatManager.bytesSent.Record((int)item.MessageData.Count);
+                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.RPCQueueManager.QueueItemType messageType, ulong clientId, float time);
+        public delegate void ReceiveCallbackType(BitStream messageStream, MLAPI.RpcQueueContainer.QueueItemType messageType, ulong clientId, float time);
 
         /// <summary>
         /// SendItems
@@ -185,7 +185,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.RPCQueueManager.QueueItemType messageType, ulong clientId, float receiveTime)
+        public int ReceiveItems(in BitStream messageStream, ReceiveCallbackType receiveCallback, MLAPI.RpcQueueContainer.QueueItemType messageType, ulong clientId, float receiveTime)
         {
             using PooledBitStream copy = PooledBitStream.Get();
             do

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

@@ -1,3 +1,7 @@
+/// About the Network Update Loop
+/// The NetworkUpdateEngine is a temporary solution for the network update loop implementation.
+/// This will be revised with a more robust and modular implementation in the near future.
+
 using System;
 using System.Text;
 using UnityEngine;

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

@@ -38,6 +38,9 @@ internal enum NExec
             Client = 2
         }
 
+        /// <summary>
+        /// This is a temporary solution for channel names and the below hardcoded value might not be mandatory in the future.
+        /// </summary>
         private const string StandardRpc_ChannelName = "STDRPC";
 
 #pragma warning disable 414
@@ -48,13 +51,9 @@ internal enum NExec
         // RuntimeAccessModifiersILPP will make this `protected`
         internal BitWriter BeginSendServerRpc(ServerRpcSendParams sendParams, bool isReliable)
         {
-            var rpcQueueMananger = NetworkingManager.Singleton.RpcQueueManager;
-            if (rpcQueueMananger == null)
-            {
-                return null;
-            }
+            var rpcQueueMananger = NetworkingManager.Singleton.rpcQueueContainer;
 
-            var writer = rpcQueueMananger.BeginAddQueueItemToOutboundFrame(RPCQueueManager.QueueItemType.ServerRpc, Time.realtimeSinceStartup, StandardRpc_ChannelName, 0, NetworkingManager.Singleton.ServerClientId, null);
+            var writer = rpcQueueMananger.BeginAddQueueItemToOutboundFrame(RpcQueueContainer.QueueItemType.ServerRpc, Time.realtimeSinceStartup, StandardRpc_ChannelName, 0, NetworkingManager.Singleton.ServerClientId, null);
             writer.WriteUInt64Packed(NetworkId); // NetworkObjectId
             writer.WriteUInt16Packed(GetBehaviourId()); // NetworkBehaviourId
             return writer;
@@ -65,21 +64,17 @@ internal void EndSendServerRpc(BitWriter writer, ServerRpcSendParams sendParams,
         {
             if (writer == null) return;
 
-            var rpcQueueMananger = NetworkingManager.Singleton.RpcQueueManager;
+            var rpcQueueMananger = NetworkingManager.Singleton.rpcQueueContainer;
             rpcQueueMananger?.EndAddQueueItemToOutboundFrame(writer);
         }
 
         // RuntimeAccessModifiersILPP will make this `protected`
         internal BitWriter BeginSendClientRpc(ClientRpcSendParams sendParams, bool isReliable)
         {
             //This will start a new queue item entry and will then return the writer to the current frame's stream
-            var rpcQueueMananger = NetworkingManager.Singleton.RpcQueueManager;
-            if (rpcQueueMananger == null)
-            {
-                return null;
-            }
+            var rpcQueueMananger = NetworkingManager.Singleton.rpcQueueContainer;
 
-            var writer = rpcQueueMananger.BeginAddQueueItemToOutboundFrame(RPCQueueManager.QueueItemType.ClientRpc, Time.realtimeSinceStartup, StandardRpc_ChannelName, 0, NetworkId, sendParams.TargetClientIds ?? NetworkingManager.Singleton.ConnectedClientsList.Select(c => c.ClientId).ToArray());
+            var writer = rpcQueueMananger.BeginAddQueueItemToOutboundFrame(RpcQueueContainer.QueueItemType.ClientRpc, Time.realtimeSinceStartup, StandardRpc_ChannelName, 0, NetworkId, sendParams.TargetClientIds ?? NetworkingManager.Singleton.ConnectedClientsList.Select(c => c.ClientId).ToArray());
             writer.WriteUInt64Packed(NetworkId); // NetworkObjectId
             writer.WriteUInt16Packed(GetBehaviourId()); // NetworkBehaviourId
             return writer;
@@ -90,7 +85,7 @@ internal void EndSendClientRpc(BitWriter writer, ClientRpcSendParams sendParams,
         {
             if (writer == null) return;
 
-            var rpcQueueMananger = NetworkingManager.Singleton.RpcQueueManager;
+            var rpcQueueMananger = NetworkingManager.Singleton.rpcQueueContainer;
             rpcQueueMananger?.EndAddQueueItemToOutboundFrame(writer);
         }
 

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

@@ -70,7 +70,7 @@ public class NetworkingManager : MonoBehaviour
         [HideInInspector]
         public bool LoopbackEnabled;
 
-        public RPCQueueManager RpcQueueManager { get; private set; }
+        public RpcQueueContainer rpcQueueContainer { get; private set; }
 
         /// <summary>
         /// A synchronized time, represents the time in seconds since the server application started. Is replicated across all clients
@@ -653,7 +653,7 @@ private void OnEnable()
 
         private void OnDestroy()
         {
-            RpcQueueManager?.OnExiting();
+            rpcQueueContainer?.OnExiting();
 
             if (Singleton != null && Singleton == this)
             {
@@ -679,20 +679,20 @@ private void Shutdown()
             if (NetworkConfig != null && NetworkConfig.NetworkTransport != null) //The Transport is set during Init time, thus it is possible for the Transport to be null
                 NetworkConfig.NetworkTransport.Shutdown();
 
-            if (RpcQueueManager != null)
+            if (rpcQueueContainer != null)
             {
-                RpcQueueManager.Shutdown();
-                RpcQueueManager = null;
+                rpcQueueContainer.Shutdown();
+                rpcQueueContainer = null;
             }
         }
 
 
         private void Awake()
         {
-            RpcQueueManager = new RPCQueueManager(LoopbackEnabled);
+            rpcQueueContainer = new RpcQueueContainer(LoopbackEnabled);
             //Note: Since frame history is not being used, this is set to 0
             //To test frame history, increase the number to (n) where n > 0
-            RpcQueueManager?.Initialize(0);
+            rpcQueueContainer.Initialize(0);
 
             NetworkUpdateManager.RegisterNetworkUpdateAction(NetworkPreUpdate, NetworkUpdateManager.NetworkUpdateStages.PREUPDATE);
             NetworkUpdateManager.RegisterNetworkUpdateAction(NetworkFixedUpdate, NetworkUpdateManager.NetworkUpdateStages.FIXEDUPDATE);
@@ -721,9 +721,9 @@ private void NetworkPreUpdate()
                     s_ReceiveTick.Begin();
 #endif
                     bool IsLoopBack = false;
-                    if (RpcQueueManager != null)
+                    if (rpcQueueContainer != null)
                     {
-                        IsLoopBack = RpcQueueManager.IsLoopBack();
+                        IsLoopBack = rpcQueueContainer.IsLoopBack();
                     }
 
                     // @mfatihmar (Unity) Begin: Temporary, inbound RPC queue will replace this workaround
@@ -766,7 +766,7 @@ private void NetworkPreUpdate()
 
         private void NetworkFixedUpdate()
         {
-            RpcQueueManager?.ProcessAndFlushRPCQueue(RPCQueueManager.RPCQueueProcessingTypes.Receive);
+            rpcQueueContainer.ProcessAndFlushRPCQueue(RpcQueueContainer.RPCQueueProcessingTypes.Receive);
         }
 
         /// <summary>
@@ -856,7 +856,7 @@ private void NetworkUpdate()
         /// </summary>
         private void NetworkLateUpdate()
         {
-            RpcQueueManager?.ProcessAndFlushRPCQueue(RPCQueueManager.RPCQueueProcessingTypes.Send);
+            rpcQueueContainer.ProcessAndFlushRPCQueue(RpcQueueContainer.RPCQueueProcessingTypes.Send);
         }
 
         internal void UpdateNetworkTime(ulong clientId, float netTime, float receiveTime, bool warp = false)
@@ -1165,7 +1165,7 @@ internal void HandleIncomingData(ulong clientId, string channelName, ArraySegmen
                         {
                             if (IsServer)
                             {
-                                batcher.ReceiveItems(messageStream, ReceiveCallback, RPCQueueManager.QueueItemType.ServerRpc, clientId, receiveTime);
+                                batcher.ReceiveItems(messageStream, ReceiveCallback, RpcQueueContainer.QueueItemType.ServerRpc, clientId, receiveTime);
                             }
                             ProfilerStatManager.rpcBatchesRcvd.Record();
                             break;
@@ -1174,7 +1174,7 @@ internal void HandleIncomingData(ulong clientId, string channelName, ArraySegmen
                         {
                             if (IsClient)
                             {
-                                batcher.ReceiveItems(messageStream, ReceiveCallback, RPCQueueManager.QueueItemType.ClientRpc, clientId, receiveTime);
+                                batcher.ReceiveItems(messageStream, ReceiveCallback, RpcQueueContainer.QueueItemType.ClientRpc, clientId, receiveTime);
                             }
                             ProfilerStatManager.rpcBatchesRcvd.Record();
                             break;
@@ -1192,10 +1192,10 @@ internal void HandleIncomingData(ulong clientId, string channelName, ArraySegmen
 #endif
         }
 
-        private static void ReceiveCallback(BitStream messageStream, MLAPI.RPCQueueManager.QueueItemType messageType, ulong clientId, float receiveTime)
+        private static void ReceiveCallback(BitStream messageStream, MLAPI.RpcQueueContainer.QueueItemType messageType, ulong clientId, float receiveTime)
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (messageType == RPCQueueManager.QueueItemType.ServerRpc)
+            if (messageType == RpcQueueContainer.QueueItemType.ServerRpc)
             {
                 s_MLAPIServerSTDRPCQueued.Begin();
             }
@@ -1206,7 +1206,7 @@ private static void ReceiveCallback(BitStream messageStream, MLAPI.RPCQueueManag
 #endif
             InternalMessageHandler.RPCReceiveQueueItem(clientId, messageStream, receiveTime, messageType);
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (messageType == RPCQueueManager.QueueItemType.ServerRpc)
+            if (messageType == RpcQueueContainer.QueueItemType.ServerRpc)
             {
                 s_MLAPIServerSTDRPCQueued.End();
             }
@@ -1227,9 +1227,9 @@ public static void InvokeRpc(FrameQueueItem queueItem)
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_InvokeRPC.Begin();
 #endif
-            var networkObjectId = queueItem.StreamReader.ReadUInt64Packed();
-            var networkBehaviourId = queueItem.StreamReader.ReadUInt16Packed();
-            var networkMethodId = queueItem.StreamReader.ReadUInt32Packed();
+            var networkObjectId = queueItem.streamReader.ReadUInt64Packed();
+            var networkBehaviourId = queueItem.streamReader.ReadUInt16Packed();
+            var networkMethodId = queueItem.streamReader.ReadUInt32Packed();
 
             if (__ntable.ContainsKey(networkMethodId))
             {
@@ -1239,7 +1239,7 @@ public static void InvokeRpc(FrameQueueItem queueItem)
                 var networkBehaviour = networkObject.GetBehaviourAtOrderIndex(networkBehaviourId);
                 if (ReferenceEquals(networkBehaviour, null)) return;
 
-                __ntable[networkMethodId](networkBehaviour, queueItem.StreamReader, queueItem.NetworkId);
+                __ntable[networkMethodId](networkBehaviour, queueItem.streamReader, queueItem.networkId);
             }
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR

com.unity.multiplayer.mlapi/Runtime/Core/RPCQueue/FrameQueueItem.cs

@@ -8,19 +8,21 @@ namespace MLAPI
     /// FrameQueueItem
     /// Container structure for RPCs written to the Queue Frame
     /// Used for both Inbound and Outbound RPCs
-    /// NOTE: This could eventually become obsolete as other systems mature
+    /// NOTE: This structure will change in the near future and is in a state of flux.
+    /// This will include removing specific properties or changing property types (i.e. Channel could become a byte value)
     /// </summary>
     public struct FrameQueueItem
     {
-        public RPCQueueManager.QueueItemType QueueItemType;
-        public SecuritySendFlags        SendFlags;
-        public ulong                    NetworkId;          //Sender's network Identifier
-        public string                   Channel;
-        public ulong[]                  ClientIds;          //Server invoked Client RPCs only
-        public long                     StreamSize;
-        public PooledBitWriter          StreamWriter;
-        public PooledBitReader          StreamReader;
-        public PooledBitStream          ItemStream;
-        public ArraySegment<byte>       MessageData;
+        public RpcQueueContainer.QueueItemType queueItemType;
+        public SecuritySendFlags        sendFlags;
+        public ulong                    networkId;          //Sender's network Identifier
+        public string                   channel;
+        public ulong[]                  clientIds;          //Server invoked Client RPCs only
+        public long                     streamSize;
+        public float                    timeStamp;
+        public PooledBitWriter          streamWriter;
+        public PooledBitReader          streamReader;
+        public PooledBitStream          itemStream;
+        public ArraySegment<byte>       messageData;
     }
 }