Unity-Technologies · mattwalsh-unity · Dec 2, 2021 · Apr 30, 2021 · Oct 22, 2021 · Jul 20, 2021
@@ -7,6 +7,10 @@ public class NetworkBehaviourUpdater
     {
         private HashSet<NetworkObject> m_Touched = new HashSet<NetworkObject>();
 
+        // reused each call to NetworkBehaviourUpdate to avoid GC.
+        //  should investigate using a native container
+        private HashSet<NetworkObject> m_InterestUpdateThisFrame = new HashSet<NetworkObject>();
+
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
         private ProfilerMarker m_NetworkBehaviourUpdate = new ProfilerMarker($"{nameof(NetworkBehaviour)}.{nameof(NetworkBehaviourUpdate)}");
 #endif
@@ -24,12 +28,15 @@ internal void NetworkBehaviourUpdate(NetworkManager networkManager)
                     for (int i = 0; i < networkManager.ConnectedClientsList.Count; i++)
                     {
                         var client = networkManager.ConnectedClientsList[i];
-                        var spawnedObjs = networkManager.SpawnManager.SpawnedObjectsList;
-                        m_Touched.UnionWith(spawnedObjs);
-                        foreach (var sobj in spawnedObjs)
+
+                        m_InterestUpdateThisFrame.Clear();
+                        networkManager.InterestManager.QueryFor(ref client.PlayerObject, ref m_InterestUpdateThisFrame);
+                        foreach (var sobj in m_InterestUpdateThisFrame)
+
                         {
                             if (sobj.IsNetworkVisibleTo(client.ClientId))
                             {
+                                m_Touched.Add(sobj);
                                 // Sync just the variables for just the objects this client sees
                                 for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++)
                                 {

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using Unity.Collections;
 using Unity.Collections.LowLevel.Unsafe;
+using Unity.Netcode.Interest;
 using UnityEngine;
 #if UNITY_EDITOR
 using UnityEditor;
@@ -53,13 +54,29 @@ internal static string PrefabDebugHelper(NetworkPrefab networkPrefab)
             return $"{nameof(NetworkPrefab)} \"{networkPrefab.Prefab.gameObject.name}\"";
         }
 
+        private InterestManager<NetworkObject> m_InterestManager;
+
+        // For unit (vs. integration) testing and for better decoupling, we don't want to have to require Initialize()
+        //  to use the InterestManager
+        internal InterestManager<NetworkObject> InterestManager
+        {
+            get
+            {
+                if (m_InterestManager == null)
+                {
+                    m_InterestManager = new InterestManager<NetworkObject>();
+                }
+                return m_InterestManager;
+            }
+        }
         internal SnapshotSystem SnapshotSystem { get; private set; }
         internal NetworkBehaviourUpdater BehaviourUpdater { get; private set; }
 
         internal MessagingSystem MessagingSystem { get; private set; }
 
         private NetworkPrefabHandler m_PrefabHandler;
 
+
         public NetworkPrefabHandler PrefabHandler
         {
             get
@@ -1099,6 +1116,11 @@ internal void ShutdownInternal()
                 NetworkTickSystem = null;
             }
 
+            if (m_InterestManager != null)
+            {
+                m_InterestManager = null;
+            }
+
             if (MessagingSystem != null)
             {
                 MessagingSystem.Dispose();

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using Unity.Netcode.Interest;
+
 using UnityEngine;
 
 namespace Unity.Netcode
@@ -10,12 +12,38 @@ namespace Unity.Netcode
     /// </summary>
     [AddComponentMenu("Netcode/" + nameof(NetworkObject), -99)]
     [DisallowMultipleComponent]
-    public sealed class NetworkObject : MonoBehaviour
+
+    public sealed class NetworkObject : MonoBehaviour, IInterestObject<NetworkObject>
     {
         [HideInInspector]
         [SerializeField]
         internal uint GlobalObjectIdHash;
 
+        private List<IInterestNode<NetworkObject>> m_InterestNodes = new List<IInterestNode<NetworkObject>>();
+
+        public void AddInterestNode(IInterestNode<NetworkObject> node)
+        {
+            if (!m_InterestNodes.Contains(node))
+            {
+                node.AddObject(this);
+                m_InterestNodes.Add(node);
+            }
+        }
+
+        public void RemoveInterestNode(IInterestNode<NetworkObject> node)
+        {
+            if (m_InterestNodes.Contains(node))
+            {
+                node.RemoveObject(this);
+                m_InterestNodes.Remove(node);
+            }
+        }
+
+        public List<IInterestNode<NetworkObject>> GetInterestNodes()
+        {
+            return m_InterestNodes;
+        }
+
 #if UNITY_EDITOR
         private void OnValidate()
         {
@@ -193,6 +221,7 @@ public HashSet<ulong>.Enumerator GetObservers()
             return Observers.GetEnumerator();
         }
 
+
         /// <summary>
         /// Whether or not this object is visible to a specific client
         /// </summary>
@@ -1155,5 +1184,6 @@ internal uint HostCheckForGlobalObjectIdHashOverride()
 
             return GlobalObjectIdHash;
         }
+
     }
 }
@@ -0,0 +1,13 @@
+using Unity.Netcode.Interest;
+
+namespace Unity.Netcode
+{
+    public class AddAllInterestKernel : IInterestKernel<NetworkObject>
+    {
+
+        public bool QueryFor(NetworkObject clientNetworkObject, NetworkObject obj)
+        {
+            return true;
+        }
+    }
+}
@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+namespace Unity.Netcode.Interest
+{
+    internal interface IInterestObject<TObject>
+    {
+        public void AddInterestNode(IInterestNode<TObject> obj);
+        public void RemoveInterestNode(IInterestNode<TObject> obj);
+        public List<IInterestNode<TObject>> GetInterestNodes();
+    }
+
+    // interest *system* instead of interest node ?
+    internal class InterestManager<TObject> where TObject : IInterestObject<TObject>
+    {
+        private readonly InterestNodeStatic<TObject> m_DefaultInterestNode = new InterestNodeStatic<TObject>();
+
+        // Trigger the Interest system to do an update sweep on any Interest nodes
+        //  I am associated with
+        public void UpdateObject(ref TObject obj)
+        {
+            List<IInterestNode<TObject>> nodes = obj.GetInterestNodes();
+            foreach (var node in nodes)
+            {
+                node.UpdateObject(obj);
+            }
+        }
+
+        public InterestManager()
+        {
+            // This is the node objects will be added to if no replication group is
+            //  specified, which means they always get replicated
+            m_ChildNodes = new HashSet<IInterestNode<TObject>> { m_DefaultInterestNode };
+        }
+
+        public void AddObject(ref TObject obj)
+        {
+            // If this new object has no associated Interest Nodes, then we put it in the
+            //  default node, which all clients will then get.
+            //
+            // That is, if you don't opt into the system behavior is the same as before
+            //  the Interest system was added
+
+            List<IInterestNode<TObject>> nodes = obj.GetInterestNodes();
+
+            if (nodes.Count > 0)
+            {
+                // I am walking through each of the interest nodes that this object has
+                foreach (var node in nodes)
+                {
+                    // the Interest Manager lazily adds nodes to itself when it sees
+                    //  new nodes that associate with the objects being added
+                    m_ChildNodes.Add(node);
+                }
+            }
+            else
+            {
+                // if the object doesn't have any nodes, we assign it to the default node
+                AddDefaultInterestNode(obj);
+            }
+        }
+
+        public void AddDefaultInterestNode(TObject obj)
+        {
+            obj.AddInterestNode(m_DefaultInterestNode);
+        }
+
+        public void RemoveObject(ref TObject obj)
+        {
+            List<IInterestNode<TObject>> nodes = obj.GetInterestNodes();
+            foreach (var node in nodes)
+            {
+                if (node == null)
+                {
+                    continue;
+                }
+                node.RemoveObject(obj);
+            }
+        }
+
+        public void QueryFor(ref TObject client, ref HashSet<TObject> results)
+        {
+            foreach (var c in m_ChildNodes)
+            {
+                c.QueryFor(client, results);
+            }
+        }
+
+        private HashSet<IInterestNode<TObject>> m_ChildNodes;
+    }
+}
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace Unity.Netcode.Interest
+{
+    public interface IInterestNode<TObject>
+    {
+        public void QueryFor(TObject client, HashSet<TObject> results);
+        public void AddObject(TObject obj);
+        public void RemoveObject(TObject obj);
+        public void UpdateObject(TObject obj);
+        public void AddAdditiveKernel(IInterestKernel<TObject> kernel);
+        public void AddSubtractiveKernel(IInterestKernel<TObject> kernel);
+    };
+
+    public interface IInterestKernel<TObject>
+    {
+        public bool QueryFor(TObject client, TObject obj);
+    }
+}