chore: start optimize work + renamed SceneObject

Author: noellie-velez

com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs

@@ -1119,15 +1119,15 @@ internal void ApprovedPlayerSpawn(ulong clientId, uint playerPrefabHash)
 
                 var message = new CreateObjectMessage
                 {
-                    ObjectInfo = ConnectedClients[clientId].PlayerObject.GetMessageSceneObject(clientPair.Key),
+                    ObjectSynchronizerInfo = ConnectedClients[clientId].PlayerObject.GetMessageForSynchronization(clientPair.Key),
                     IncludesSerializedObject = true,
                 };
 
-                message.ObjectInfo.Hash = playerPrefabHash;
-                message.ObjectInfo.IsSceneObject = false;
-                message.ObjectInfo.HasParent = false;
-                message.ObjectInfo.IsPlayerObject = true;
-                message.ObjectInfo.OwnerClientId = clientId;
+                message.ObjectSynchronizerInfo.Hash = playerPrefabHash;
+                message.ObjectSynchronizerInfo.IsSceneObject = false;
+                message.ObjectSynchronizerInfo.HasParent = false;
+                message.ObjectSynchronizerInfo.IsPlayerObject = true;
+                message.ObjectSynchronizerInfo.OwnerClientId = clientId;
                 var size = SendMessage(ref message, MessageDeliveryType<CreateObjectMessage>.DefaultDelivery, clientPair.Key);
                 NetworkManager.NetworkMetrics.TrackObjectSpawnSent(clientPair.Key, ConnectedClients[clientId].PlayerObject, size);
             }

com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs

@@ -2828,87 +2828,88 @@ public NetworkBehaviour GetNetworkBehaviourAtOrderIndex(ushort index)
             return ChildNetworkBehaviours[index];
         }
 
-        internal struct SceneObject
+        internal struct NetworkObjectSynchronizer
         {
             private ushort m_BitField;
             public uint Hash;
             public ulong NetworkObjectId;
             public ulong OwnerClientId;
             public ushort OwnershipFlags;
 
-            public bool IsPlayerObject
-            {
-                get => ByteUtility.GetBit(m_BitField, 0);
-                set => ByteUtility.SetBit(ref m_BitField, 0, value);
-            }
-            public bool HasParent
-            {
-                get => ByteUtility.GetBit(m_BitField, 1);
-                set => ByteUtility.SetBit(ref m_BitField, 1, value);
-            }
-            public bool IsSceneObject
-            {
-                get => ByteUtility.GetBit(m_BitField, 2);
-                set => ByteUtility.SetBit(ref m_BitField, 2, value);
-            }
-            public bool HasTransform
-            {
-                get => ByteUtility.GetBit(m_BitField, 3);
-                set => ByteUtility.SetBit(ref m_BitField, 3, value);
-            }
+            private const ushort k_IsPlayerObject = 0x001;
+            private const ushort k_HasParent = 0x002;
+            private const ushort k_IsSceneObject = 0x004;
+            private const ushort k_HasTransform = 0x008;
+            private const ushort k_IsLatestParentSet = 0x010;
+            private const ushort k_WorldPositionStays = 0x020;
+            private const ushort k_DestroyWithScene = 0x040;
+            private const ushort k_DontDestroyWithOwner = 0x080;
+            private const ushort k_HasOwnershipFlags = 0x100;
+            private const ushort k_SyncObservers = 0x200;
+            private const ushort k_SpawnWithObservers = 0x400;
+            private const ushort k_HasInstantiationData = 0x800;
 
-            public bool IsLatestParentSet
-            {
-                get => ByteUtility.GetBit(m_BitField, 4);
-                set => ByteUtility.SetBit(ref m_BitField, 4, value);
-            }
+            public bool IsPlayerObject;
+            public bool HasParent;
+            public bool IsSceneObject;
+            public bool HasTransform;
 
-            public bool WorldPositionStays
-            {
-                get => ByteUtility.GetBit(m_BitField, 5);
-                set => ByteUtility.SetBit(ref m_BitField, 5, value);
-            }
+            public bool IsLatestParentSet;
+
+            public bool WorldPositionStays;
 
             /// <summary>
             /// Even though the server sends notifications for NetworkObjects that get
             /// destroyed when a scene is unloaded, we want to synchronize this so
             /// the client side can use it as part of a filter for automatically migrating
             /// to the current active scene when its scene is unloaded. (only for dynamically spawned)
             /// </summary>
-            public bool DestroyWithScene
-            {
-                get => ByteUtility.GetBit(m_BitField, 6);
-                set => ByteUtility.SetBit(ref m_BitField, 6, value);
-            }
+            public bool DestroyWithScene;
 
-            public bool DontDestroyWithOwner
-            {
-                get => ByteUtility.GetBit(m_BitField, 7);
-                set => ByteUtility.SetBit(ref m_BitField, 7, value);
-            }
+            public bool DontDestroyWithOwner;
 
-            public bool HasOwnershipFlags
-            {
-                get => ByteUtility.GetBit(m_BitField, 8);
-                set => ByteUtility.SetBit(ref m_BitField, 8, value);
-            }
+            public bool HasOwnershipFlags;
 
-            public bool SyncObservers
-            {
-                get => ByteUtility.GetBit(m_BitField, 9);
-                set => ByteUtility.SetBit(ref m_BitField, 9, value);
-            }
+            public bool SyncObservers;
+
+            public bool SpawnWithObservers;
+
+            public bool HasInstantiationData;
 
-            public bool SpawnWithObservers
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal ushort GetBitsetRepresentation()
             {
-                get => ByteUtility.GetBit(m_BitField, 10);
-                set => ByteUtility.SetBit(ref m_BitField, 10, value);
+                ushort bitset = 0;
+                if(IsPlayerObject) { bitset |= k_IsPlayerObject; };
+                if(HasParent) { bitset |= k_HasParent; };
+                if(IsSceneObject) { bitset |= k_IsSceneObject; };
+                if(HasTransform) { bitset |= k_HasTransform; };
+                if(IsLatestParentSet) { bitset |= k_IsLatestParentSet; };
+                if(WorldPositionStays) { bitset |= k_WorldPositionStays; };
+                if(DestroyWithScene) { bitset |= k_DestroyWithScene; };
+                if(DontDestroyWithOwner) { bitset |= k_DontDestroyWithOwner; };
+                if(HasOwnershipFlags) { bitset |= k_HasOwnershipFlags; };
+                if(SyncObservers) { bitset |= k_SyncObservers; };
+                if(SpawnWithObservers) { bitset |= k_SpawnWithObservers; };
+                if(HasInstantiationData) { bitset |= k_HasInstantiationData; };
+                return bitset;
             }
 
-            public bool HasInstantiationData
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void SetStateFromBitset(ushort bitset)
             {
-                get => ByteUtility.GetBit(m_BitField, 11);
-                set => ByteUtility.SetBit(ref m_BitField, 11, value);
+                IsPlayerObject = (bitset & k_IsPlayerObject) != 0;
+                HasParent = (bitset & k_HasParent) != 0;
+                IsSceneObject = (bitset & k_IsSceneObject) != 0;
+                HasTransform = (bitset & k_HasTransform) != 0;
+                IsLatestParentSet = (bitset & k_IsLatestParentSet) != 0;
+                WorldPositionStays = (bitset & k_WorldPositionStays) != 0;
+                DestroyWithScene = (bitset & k_DestroyWithScene) != 0;
+                DontDestroyWithOwner = (bitset & k_DontDestroyWithOwner) != 0;
+                HasOwnershipFlags = (bitset & k_HasOwnershipFlags) != 0;
+                SyncObservers = (bitset & k_SyncObservers) != 0;
+                SpawnWithObservers = (bitset & k_SpawnWithObservers) != 0;
+                HasInstantiationData = (bitset & k_HasInstantiationData) != 0;
             }
 
             // When handling the initial synchronization of NetworkObjects,
@@ -3155,9 +3156,9 @@ internal void SynchronizeNetworkBehaviours<T>(ref BufferSerializer<T> serializer
             }
         }
 
-        internal SceneObject GetMessageSceneObject(ulong targetClientId = NetworkManager.ServerClientId, bool syncObservers = false)
+        internal NetworkObjectSynchronizer GetMessageForSynchronization(ulong targetClientId = NetworkManager.ServerClientId, bool syncObservers = false)
         {
-            var obj = new SceneObject
+            var obj = new NetworkObjectSynchronizer
             {
                 HasParent = transform.parent != null,
                 WorldPositionStays = m_CachedWorldPositionStays,
@@ -3211,7 +3212,7 @@ internal SceneObject GetMessageSceneObject(ulong targetClientId = NetworkManager
                     syncScaleLocalSpaceRelative = obj.HasParent;
                 }
 
-                obj.Transform = new SceneObject.TransformData
+                obj.Transform = new NetworkObjectSynchronizer.TransformData
                 {
                     // If we are parented and we have the m_CachedWorldPositionStays disabled, then use local space
                     // values as opposed world space values.
@@ -3230,35 +3231,35 @@ internal SceneObject GetMessageSceneObject(ulong targetClientId = NetworkManager
         }
 
         /// <summary>
-        /// Used to deserialize a serialized scene object which occurs
+        /// Used to deserialize a serialized <see cref="NetworkObjectSynchronizer"/> which occurs
         /// when the client is approved or during a scene transition
         /// </summary>
-        /// <param name="sceneObject">Deserialized scene object data</param>
+        /// <param name="networkObjectSynchronizer">Deserialized scene object data</param>
         /// <param name="reader">FastBufferReader for the NetworkVariable data</param>
         /// <param name="networkManager">NetworkManager instance</param>
         /// <param name="invokedByMessage">will be true if invoked by CreateObjectMessage</param>
         /// <returns>The deserialized NetworkObject or null if deserialization failed</returns>
-        internal static NetworkObject AddSceneObject(in SceneObject sceneObject, FastBufferReader reader, NetworkManager networkManager, bool invokedByMessage = false)
+        internal static NetworkObject AddClientNetworkObject(in NetworkObjectSynchronizer networkObjectSynchronizer, FastBufferReader reader, NetworkManager networkManager, bool invokedByMessage = false)
         {
-            var endOfSynchronizationData = reader.Position + sceneObject.SynchronizationDataSize;
+            var endOfSynchronizationData = reader.Position + networkObjectSynchronizer.SynchronizationDataSize;
 
             byte[] instantiationData = null;
-            if (sceneObject.HasInstantiationData)
+            if (networkObjectSynchronizer.HasInstantiationData)
             {
                 reader.ReadValueSafe(out instantiationData);
             }
 
 
             // Attempt to create a local NetworkObject
-            var networkObject = networkManager.SpawnManager.CreateLocalNetworkObject(sceneObject, instantiationData);
+            var networkObject = networkManager.SpawnManager.CreateLocalNetworkObject(networkObjectSynchronizer, instantiationData);
 
 
             if (networkObject == null)
             {
                 // Log the error that the NetworkObject failed to construct
                 if (networkManager.LogLevel <= LogLevel.Normal)
                 {
-                    NetworkLog.LogError($"Failed to spawn {nameof(NetworkObject)} for Hash {sceneObject.Hash}.");
+                    NetworkLog.LogError($"Failed to spawn {nameof(NetworkObject)} for Hash {networkObjectSynchronizer.Hash}.");
                 }
 
                 try
@@ -3279,7 +3280,7 @@ internal static NetworkObject AddSceneObject(in SceneObject sceneObject, FastBuf
 
             // This will get set again when the NetworkObject is spawned locally, but we set it here ahead of spawning
             // in order to be able to determine which NetworkVariables the client will be allowed to read.
-            networkObject.OwnerClientId = sceneObject.OwnerClientId;
+            networkObject.OwnerClientId = networkObjectSynchronizer.OwnerClientId;
 
             // Special Case: Invoke NetworkBehaviour.OnPreSpawn methods here before SynchronizeNetworkBehaviours
             networkObject.InvokeBehaviourNetworkPreSpawn();
@@ -3307,7 +3308,7 @@ internal static NetworkObject AddSceneObject(in SceneObject sceneObject, FastBuf
             // being told we do not have a parent, then we want to clear the latest parent so it is not automatically
             // "re-parented" to the original parent. This can happen if not unloading the scene and the parenting of
             // the in-scene placed Networkobject changes several times over different sessions.
-            if (sceneObject.IsSceneObject && !sceneObject.HasParent && networkObject.m_LatestParent.HasValue)
+            if (networkObjectSynchronizer.IsSceneObject && !networkObjectSynchronizer.HasParent && networkObject.m_LatestParent.HasValue)
             {
                 networkObject.m_LatestParent = null;
             }
@@ -3320,19 +3321,19 @@ internal static NetworkObject AddSceneObject(in SceneObject sceneObject, FastBuf
 
             // Invoke the non-authority local spawn method
             // (It also invokes post spawn and handles processing derferred messages)
-            networkManager.SpawnManager.NonAuthorityLocalSpawn(networkObject, sceneObject, sceneObject.DestroyWithScene);
+            networkManager.SpawnManager.NonAuthorityLocalSpawn(networkObject, networkObjectSynchronizer, networkObjectSynchronizer.DestroyWithScene);
 
-            if (sceneObject.SyncObservers)
+            if (networkObjectSynchronizer.SyncObservers)
             {
-                foreach (var observer in sceneObject.Observers)
+                foreach (var observer in networkObjectSynchronizer.Observers)
                 {
                     networkObject.Observers.Add(observer);
                 }
             }
 
             if (networkManager.DistributedAuthorityMode)
             {
-                networkObject.SpawnWithObservers = sceneObject.SpawnWithObservers;
+                networkObject.SpawnWithObservers = networkObjectSynchronizer.SpawnWithObservers;
             }
 
             // If this was not invoked by a message handler, we are in distributed authority mode, and we are spawning with observers or

com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -160,7 +160,7 @@ public void Serialize(FastBufferWriter writer, int targetVersion)
                     {
                         sobj.Observers.Add(OwnerClientId);
                         // In distributed authority mode, we send the currently known observers of each NetworkObject to the client being synchronized.
-                        var sceneObject = sobj.GetMessageSceneObject(OwnerClientId, IsDistributedAuthority);
+                        var sceneObject = sobj.GetMessageForSynchronization(OwnerClientId, IsDistributedAuthority);
                         sceneObject.Serialize(writer);
                         ++sceneObjectCount;
                     }
@@ -342,9 +342,9 @@ public void Handle(ref NetworkContext context)
                 // to create a list to hold the data. This is a breach of convention for performance reasons.
                 for (ushort i = 0; i < sceneObjectCount; i++)
                 {
-                    var sceneObject = new NetworkObject.SceneObject();
+                    var sceneObject = new NetworkObject.NetworkObjectSynchronizer();
                     sceneObject.Deserialize(m_ReceivedSceneObjectData);
-                    NetworkObject.AddSceneObject(sceneObject, m_ReceivedSceneObjectData, networkManager);
+                    NetworkObject.AddClientNetworkObject(sceneObject, m_ReceivedSceneObjectData, networkManager);
                 }
 
                 if (networkManager.AutoSpawnPlayerPrefabClientSide)