chore: migrate NetworkTransform away from using named messages over to NetworkTransformMessage [MTT-7535] (#2810)

* update
Adding the NetworkTransformMessage
Expanding INetworkMessgeILPP assembly processing to Unity.Netcode.Components.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -16,6 +16,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Changed
 
+- Changed `NetworkTransform` to now use `NetworkTransformMessage` as opposed to named messages for NetworkTransformState updates. (#2810)
 - Changed `CustomMessageManager` so it no longer attempts to register or "unregister" a null or empty string and will log an error if this condition occurs. (#2807)
 
 

com.unity.netcode.gameobjects/Components/Messages.meta

@@ -0,0 +1,116 @@
+using Unity.Netcode.Components;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// NetworkTransform State Update Message
+    /// </summary>
+    internal struct NetworkTransformMessage : INetworkMessage
+    {
+        public int Version => 0;
+        public ulong NetworkObjectId;
+        public int NetworkBehaviourId;
+        public NetworkTransform.NetworkTransformState State;
+
+        private NetworkTransform m_ReceiverNetworkTransform;
+        private FastBufferReader m_CurrentReader;
+
+        private unsafe void CopyPayload(ref FastBufferWriter writer)
+        {
+            writer.WriteBytesSafe(m_CurrentReader.GetUnsafePtrAtCurrentPosition(), m_CurrentReader.Length - m_CurrentReader.Position);
+        }
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            if (m_CurrentReader.IsInitialized)
+            {
+                CopyPayload(ref writer);
+            }
+            else
+            {
+                BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
+                BytePacker.WriteValueBitPacked(writer, NetworkBehaviourId);
+                writer.WriteNetworkSerializable(State);
+            }
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            var networkManager = context.SystemOwner as NetworkManager;
+            if (networkManager == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}] System owner context was not of type {nameof(NetworkManager)}!");
+                return false;
+            }
+            var currentPosition = reader.Position;
+            ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
+            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                return false;
+            }
+            // Get the behaviour index
+            ByteUnpacker.ReadValueBitPacked(reader, out NetworkBehaviourId);
+
+            // Deserialize the state
+            reader.ReadNetworkSerializable(out State);
+
+            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+
+            // Get the target NetworkTransform
+            m_ReceiverNetworkTransform = networkObject.ChildNetworkBehaviours[NetworkBehaviourId] as NetworkTransform;
+
+            var isServerAuthoritative = m_ReceiverNetworkTransform.IsServerAuthoritative();
+            var ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
+            if (ownerAuthoritativeServerSide)
+            {
+                var ownerClientId = networkObject.OwnerClientId;
+                if (ownerClientId == NetworkManager.ServerClientId)
+                {
+                    // Ownership must have changed, ignore any additional pending messages that might have
+                    // come from a previous owner client.
+                    return true;
+                }
+
+                var networkDelivery = State.IsReliableStateUpdate() ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
+
+                // Forward the state update if there are any remote clients to foward it to
+                if (networkManager.ConnectionManager.ConnectedClientsList.Count > (networkManager.IsHost ? 2 : 1))
+                {
+                    // This is only to copy the existing and already serialized struct for forwarding purposes only.
+                    // This will not include any changes made to this struct at this particular stage of processing the message.
+                    var currentMessage = this;
+                    // Create a new reader that replicates this message
+                    currentMessage.m_CurrentReader = new FastBufferReader(reader, Collections.Allocator.None);
+                    // Rewind the new reader to the beginning of the message's payload
+                    currentMessage.m_CurrentReader.Seek(currentPosition);
+                    // Forward the message to all connected clients that are observers of the associated NetworkObject
+                    var clientCount = networkManager.ConnectionManager.ConnectedClientsList.Count;
+                    for (int i = 0; i < clientCount; i++)
+                    {
+                        var clientId = networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
+                        if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) || !networkObject.Observers.Contains(clientId))
+                        {
+                            continue;
+                        }
+                        networkManager.MessageManager.SendMessage(ref currentMessage, networkDelivery, clientId);
+                    }
+                    // Dispose of the reader used for forwarding
+                    currentMessage.m_CurrentReader.Dispose();
+                }
+            }
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            if (m_ReceiverNetworkTransform == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
+                return;
+            }
+            m_ReceiverNetworkTransform.TransformStateUpdate(ref State);
+        }
+    }
+}

com.unity.netcode.gameobjects/Components/Messages/NetworkTransformMessage.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
-using Unity.Collections;
 using Unity.Mathematics;
 using UnityEngine;
 
@@ -1330,9 +1329,6 @@ internal NetworkTransformState LocalAuthoritativeNetworkState
         private Quaternion m_CurrentRotation;
         private Vector3 m_TargetRotation;
 
-        // Used to for each instance to uniquely identify the named message
-        private string m_MessageName;
-
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void UpdatePositionInterpolator(Vector3 position, double time, bool resetInterpolator = false)
@@ -2753,21 +2749,12 @@ public override void OnNetworkSpawn()
             // Started using this again to avoid the getter processing cost of NetworkBehaviour.NetworkManager
             m_CachedNetworkManager = NetworkManager;
 
-            // Register a custom named message specifically for this instance
-            m_MessageName = $"NTU_{NetworkObjectId}_{NetworkBehaviourId}";
-            m_CachedNetworkManager.CustomMessagingManager.RegisterNamedMessageHandler(m_MessageName, TransformStateUpdate);
             Initialize();
         }
 
         /// <inheritdoc/>
         public override void OnNetworkDespawn()
         {
-            // During destroy, use NetworkBehaviour.NetworkManager as opposed to m_CachedNetworkManager
-            if (!NetworkManager.ShutdownInProgress && NetworkManager.CustomMessagingManager != null && !string.IsNullOrEmpty(m_MessageName))
-            {
-                NetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler(m_MessageName);
-            }
-
             DeregisterForTickUpdate(this);
 
             CanCommitToTransform = false;
@@ -3156,79 +3143,23 @@ public bool IsServerAuthoritative()
         }
 
         /// <summary>
-        /// Receives the <see cref="NetworkTransformState"/> named message updates
+        /// Invoked by <see cref="NetworkTransformMessage"/> to update the transform state
         /// </summary>
-        /// <param name="senderId">authority of the transform</param>
-        /// <param name="messagePayload">serialzied <see cref="NetworkTransformState"/></param>
-        private void TransformStateUpdate(ulong senderId, FastBufferReader messagePayload)
+        /// <param name="networkTransformState"></param>
+        internal void TransformStateUpdate(ref NetworkTransformState networkTransformState)
         {
-            var ownerAuthoritativeServerSide = !OnIsServerAuthoritative() && IsServer;
-            if (ownerAuthoritativeServerSide && OwnerClientId == NetworkManager.ServerClientId)
-            {
-                // Ownership must have changed, ignore any additional pending messages that might have
-                // come from a previous owner client.
-                return;
-            }
-
             // Store the previous/old state
             m_OldState = m_LocalAuthoritativeNetworkState;
 
-            // Save the current payload stream position
-            var currentPosition = messagePayload.Position;
-
-            // Deserialize the message (and determine network delivery)
-            messagePayload.ReadNetworkSerializableInPlace(ref m_LocalAuthoritativeNetworkState);
-
-            // Rewind back prior to serialization
-            messagePayload.Seek(currentPosition);
+            // Assign the new incoming state
+            m_LocalAuthoritativeNetworkState = networkTransformState;
 
-            // Get the network delivery method used to send this state update
-            var networkDelivery = m_LocalAuthoritativeNetworkState.ReliableSequenced ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
-
-            // Forward owner authoritative messages before doing anything else
-            if (ownerAuthoritativeServerSide)
-            {
-                // Forward the state update if there are any remote clients to foward it to
-                if (m_CachedNetworkManager.ConnectionManager.ConnectedClientsList.Count > (IsHost ? 2 : 1))
-                {
-                    ForwardStateUpdateMessage(messagePayload, networkDelivery);
-                }
-            }
-
-            // Apply the message
+            // Apply the state update
             OnNetworkStateChanged(m_OldState, m_LocalAuthoritativeNetworkState);
         }
 
         /// <summary>
-        /// Forwards owner authoritative state updates when received by the server
-        /// </summary>
-        /// <param name="messagePayload">the owner state message payload</param>
-        private unsafe void ForwardStateUpdateMessage(FastBufferReader messagePayload, NetworkDelivery networkDelivery)
-        {
-            var serverAuthoritative = OnIsServerAuthoritative();
-            var currentPosition = messagePayload.Position;
-            var messageSize = messagePayload.Length - currentPosition;
-            var writer = new FastBufferWriter(messageSize, Allocator.Temp);
-            using (writer)
-            {
-                writer.WriteBytesSafe(messagePayload.GetUnsafePtr(), messageSize, currentPosition);
-
-                var clientCount = m_CachedNetworkManager.ConnectionManager.ConnectedClientsList.Count;
-                for (int i = 0; i < clientCount; i++)
-                {
-                    var clientId = m_CachedNetworkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
-                    if (NetworkManager.ServerClientId == clientId || (!serverAuthoritative && clientId == OwnerClientId))
-                    {
-                        continue;
-                    }
-                    m_CachedNetworkManager.CustomMessagingManager.SendNamedMessage(m_MessageName, clientId, writer, networkDelivery);
-                }
-            }
-            messagePayload.Seek(currentPosition);
-        }
-
-        /// <summary>
-        /// Sends <see cref="NetworkTransformState"/> named message updates by the authority of the transform
+        /// Invoked by the authoritative instance to sends a <see cref="NetworkTransformMessage"/> containing the <see cref="NetworkTransformState"/>
         /// </summary>
         private void UpdateTransformState()
         {
@@ -3248,7 +3179,12 @@ private void UpdateTransformState()
             }
             var customMessageManager = m_CachedNetworkManager.CustomMessagingManager;
 
-            var writer = new FastBufferWriter(128, Allocator.Temp);
+            var networkTransformMessage = new NetworkTransformMessage()
+            {
+                NetworkObjectId = NetworkObjectId,
+                NetworkBehaviourId = NetworkBehaviourId,
+                State = m_LocalAuthoritativeNetworkState
+            };
 
             // Determine what network delivery method to use:
             // When to send reliable packets:
@@ -3259,32 +3195,32 @@ private void UpdateTransformState()
                 | m_LocalAuthoritativeNetworkState.UnreliableFrameSync | m_LocalAuthoritativeNetworkState.SynchronizeBaseHalfFloat
                 ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
 
-            using (writer)
+            // Server-host always sends updates to all clients (but itself)
+            if (IsServer)
             {
-                writer.WriteNetworkSerializable(m_LocalAuthoritativeNetworkState);
-                // Server-host always sends updates to all clients (but itself)
-                if (IsServer)
+                var clientCount = m_CachedNetworkManager.ConnectionManager.ConnectedClientsList.Count;
+                for (int i = 0; i < clientCount; i++)
                 {
-                    var clientCount = m_CachedNetworkManager.ConnectionManager.ConnectedClientsList.Count;
-                    for (int i = 0; i < clientCount; i++)
+                    var clientId = m_CachedNetworkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
+                    if (NetworkManager.ServerClientId == clientId)
                     {
-                        var clientId = m_CachedNetworkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
-                        if (NetworkManager.ServerClientId == clientId)
-                        {
-                            continue;
-                        }
-                        customMessageManager.SendNamedMessage(m_MessageName, clientId, writer, networkDelivery);
+                        continue;
                     }
+                    if (!NetworkObject.Observers.Contains(clientId))
+                    {
+                        continue;
+                    }
+                    NetworkManager.MessageManager.SendMessage(ref networkTransformMessage, networkDelivery, clientId);
                 }
-                else
-                {
-                    // Clients (owner authoritative) send messages to the server-host
-                    customMessageManager.SendNamedMessage(m_MessageName, NetworkManager.ServerClientId, writer, networkDelivery);
-                }
+            }
+            else
+            {
+                // Clients (owner authoritative) send messages to the server-host
+                NetworkManager.MessageManager.SendMessage(ref networkTransformMessage, networkDelivery, NetworkManager.ServerClientId);
             }
         }
 
-
+        #region Network Tick Registration and Handling
         private static Dictionary<NetworkManager, NetworkTransformTickRegistration> s_NetworkTickRegistration = new Dictionary<NetworkManager, NetworkTransformTickRegistration>();
 
         private static void RemoveTickUpdate(NetworkManager networkManager)
@@ -3394,6 +3330,8 @@ private static void DeregisterForTickUpdate(NetworkTransform networkTransform)
                 }
             }
         }
+
+        #endregion
     }
 
     internal interface INetworkTransformLogStateEntry

com.unity.netcode.gameobjects/Components/Messages/NetworkTransformMessage.cs.meta

@@ -21,6 +21,7 @@ internal static class CodeGenHelpers
         public const string NetcodeModuleName = "Unity.Netcode.Runtime.dll";
 
         public const string RuntimeAssemblyName = "Unity.Netcode.Runtime";
+        public const string ComponentsAssemblyName = "Unity.Netcode.Components";
 
         public static readonly string NetworkBehaviour_FullName = typeof(NetworkBehaviour).FullName;
         public static readonly string INetworkMessage_FullName = typeof(INetworkMessage).FullName;

com.unity.netcode.gameobjects/Components/NetworkTransform.cs

@@ -17,7 +17,7 @@ internal sealed class INetworkMessageILPP : ILPPInterface
     {
         public override ILPPInterface GetInstance() => this;
 
-        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName;
+        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName || compiledAssembly.Name == CodeGenHelpers.ComponentsAssemblyName;
 
         private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();