update

Fixes and updates based on the most recent changes in the unified API.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Editor/NetworkObjectEditor.cs

@@ -2,6 +2,10 @@
 #if BYPASS_DEFAULT_ENUM_DRAWER && MULTIPLAYER_SERVICES_SDK_INSTALLED
 using System.Linq;
 #endif
+#if UNIFIED_NETCODE
+using Unity.NetCode;
+using Unity.NetCode.Editor;
+#endif
 using UnityEditor;
 using UnityEngine;
 
@@ -23,6 +27,34 @@ public class NetworkObjectEditor : UnityEditor.Editor
 
         private static readonly string[] k_HiddenFields = { "m_Script" };
 
+#if UNIFIED_NETCODE
+        /// <summary>
+        /// Register for the GhostAdapter removal event.
+        /// </summary>
+        [InitializeOnLoadMethod]
+        private static void OnApplicationStart()
+        {
+            GhostAdapterEditor.OnGhostAdapterPreRemoval = OnGhostAdapterPreRemoval;
+        }
+
+        /// <summary>
+        /// Callback to remove the GhostBehaviours prior to removing GhostAdapter.
+        /// </summary>
+        /// <param name="gameObject">The <see cref="GameObject"/> with the <see cref="GhostAdapter"/> component being removed.</param>
+        private static void OnGhostAdapterPreRemoval(GameObject gameObject)
+        {
+            var ghostBehaviours = gameObject.GetComponentsInChildren<GhostBehaviour>();
+            for (int i = ghostBehaviours.Length - 1; i >= 0; i--)
+            {
+                DestroyImmediate(ghostBehaviours[i], true);
+            }
+            var networkObject = gameObject.GetComponent<NetworkObject>();
+            networkObject.GhostAdapter = null;
+            networkObject.HasGhost = false;
+            networkObject.HadBridge = true;
+        }
+#endif
+
         private void Initialize()
         {
             if (m_Initialized)

com.unity.netcode.gameobjects/Editor/NetworkTransformEditor.cs

@@ -1,3 +1,4 @@
+using System.Runtime.CompilerServices;
 using Unity.Netcode.Components;
 using UnityEditor;
 using UnityEngine;
@@ -94,9 +95,38 @@ public override void OnEnable()
             base.OnEnable();
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void SetGUIActive(bool active = true)
+        {
+#if UNIFIED_NETCODE
+            if (Application.IsPlaying(m_NetworkObject) && m_NetworkObject.HasGhost)
+            {
+                GUI.enabled = false;
+            }
+            else
+            {
+                GUI.enabled = active;
+            }
+#else
+            GUI.enabled = active;
+#endif
+
+        }
+
+        private NetworkObject m_NetworkObject;
+
         private void DisplayNetworkTransformProperties()
         {
             var networkTransform = target as NetworkTransform;
+
+#if UNIFIED_NETCODE
+            m_NetworkObject = networkTransform.GetComponent<NetworkObject>();
+            var hasGhost = m_NetworkObject.HasGhost;
+            SetGUIActive();
+#else
+            var hasGhost = false;
+#endif
+
             EditorGUILayout.LabelField("Axis to Synchronize", EditorStyles.boldLabel);
             {
                 GUILayout.BeginHorizontal();
@@ -190,7 +220,7 @@ private void DisplayNetworkTransformProperties()
             {
                 networkTransform.UseUnreliableDeltas = false;
             }
-            GUI.enabled = !networkTransform.SwitchTransformSpaceWhenParented;
+            SetGUIActive(!networkTransform.SwitchTransformSpaceWhenParented);
             if (networkTransform.SwitchTransformSpaceWhenParented)
             {
                 EditorGUILayout.BeginHorizontal();
@@ -202,11 +232,13 @@ private void DisplayNetworkTransformProperties()
             {
                 EditorGUILayout.PropertyField(m_UseUnreliableDeltas);
             }
-            GUI.enabled = true;
+
+            SetGUIActive(true);
 
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
-            GUI.enabled = !networkTransform.UseUnreliableDeltas;
+
+            SetGUIActive(!networkTransform.UseUnreliableDeltas);
             if (networkTransform.UseUnreliableDeltas)
             {
                 EditorGUILayout.BeginHorizontal();
@@ -218,7 +250,7 @@ private void DisplayNetworkTransformProperties()
             {
                 EditorGUILayout.PropertyField(m_SwitchTransformSpaceWhenParented);
             }
-            GUI.enabled = true;
+            SetGUIActive(true);
             if (m_SwitchTransformSpaceWhenParented.boolValue)
             {
                 m_TickSyncChildren.boolValue = true;
@@ -297,20 +329,23 @@ private void DisplayNetworkTransformProperties()
 
 #if COM_UNITY_MODULES_PHYSICS
             // if rigidbody is present but network rigidbody is not present
-            if (networkTransform.TryGetComponent<Rigidbody>(out _) && networkTransform.TryGetComponent<NetworkRigidbody>(out _) == false)
+            if (hasGhost && networkTransform.TryGetComponent<Rigidbody>(out _) && networkTransform.TryGetComponent<NetworkRigidbody>(out _) == false)
             {
-                EditorGUILayout.HelpBox("This GameObject contains a Rigidbody but no NetworkRigidbody.\n" +
+                EditorGUILayout.HelpBox("This GameObject contains a Rigidbody but no NetworkRigidbody.\n " +
                     "Add a NetworkRigidbody component to improve Rigidbody synchronization.", MessageType.Warning);
             }
 #endif // COM_UNITY_MODULES_PHYSICS
 
 #if COM_UNITY_MODULES_PHYSICS2D
-            if (networkTransform.TryGetComponent<Rigidbody2D>(out _) && networkTransform.TryGetComponent<NetworkRigidbody2D>(out _) == false)
+            if (!hasGhost && networkTransform.TryGetComponent<Rigidbody2D>(out _) && networkTransform.TryGetComponent<NetworkRigidbody2D>(out _) == false)
             {
                 EditorGUILayout.HelpBox("This GameObject contains a Rigidbody2D but no NetworkRigidbody2D.\n" +
                     "Add a NetworkRigidbody2D component to improve Rigidbody2D synchronization.", MessageType.Warning);
             }
 #endif // COM_UNITY_MODULES_PHYSICS2D
+#if UNIFIED_NETCODE
+            GUI.enabled = true;
+#endif
         }
 
         /// <summary>

com.unity.netcode.gameobjects/Editor/Unity.Netcode.Editor.asmdef

@@ -8,7 +8,8 @@
         "Unity.Networking.Transport",
         "Unity.Services.Core",
         "Unity.Services.Authentication",
-        "Unity.NetCode"
+        "Unity.NetCode",
+        "Unity.NetCode.Editor"
     ],
     "includePlatforms": [
         "Editor"

com.unity.netcode.gameobjects/Runtime/Components/Helpers/NetworkObjectBridge.cs

@@ -1,8 +1,5 @@
 #if UNIFIED_NETCODE
 using Unity.NetCode;
-#if UNITY_EDITOR
-using UnityEditor;
-#endif
 using UnityEngine;
 
 namespace Unity.Netcode
@@ -12,32 +9,50 @@ namespace Unity.Netcode
     /// This is a component that is added to the root of all N4E-spawned hybrid prefab instances. It is used to link
     /// <see cref="NetworkObject.SerializedObject"/> the N4E-spawned hybrid prefab instances to the incoming <see cref="CreateObjectMessage"/>
     /// specific to the N4E-spawned hybrid prefab instance that has the matching <see cref="NetworkObjectId"/>.
-    /// </summary>
+    /// </summary>   
+
+    [DefaultExecutionOrder(GhostAdapterExecutionOrder.ExecutionOrder + 1)]
+    //BREAK --- Fix this on UNIFIED side 1st
     public partial class NetworkObjectBridge : GhostBehaviour
     {
+        // DefaultExecutionOrder
+        // TODO: Define a const for the value used on GhostAdapter and use that value
+        // to set the execution order so if it changes on GhostAdapter it updates here.
 #if UNITY_EDITOR
-        [HideInInspector]
-        [SerializeField]
-        private bool m_Sorted = false;
         private void OnValidate()
         {
-            // TODO-UNIFIED: GhostAdapter must be above all GhostBehaviours in order to assure the GhostAdapter is initialized before any GhostBehaviour.
-            // This auto-sorting is required because the GhostBehaviours rely on the GhostAdapter.Awake being invoked before any GhostBehaviour.Awake.
-            if (!m_Sorted && !EditorApplication.isPlaying)
+            hideFlags = HideFlags.HideInInspector;
+
+            var ghostAdapter = GetComponent<GhostAdapter>();
+            if (ghostAdapter == null)
             {
-                while (UnityEditorInternal.ComponentUtility.MoveComponentUp(this))
-                {
-                    // Keep moving until it can't go higher
-                }
-                var ghostAdapter = gameObject.GetComponent<GhostAdapter>();
-                // Now move the GhostAdapter to the top so it is above NetworkObjectBridge
-                while (ghostAdapter != null && UnityEditorInternal.ComponentUtility.MoveComponentUp(ghostAdapter))
+                return;
+            }
+
+            // Start users with just interpolation (they can adjust this if they want prediction)
+            // to make the initial transition less problematic for users.
+            ghostAdapter.SupportedGhostModes = GhostModeMask.Interpolated;
+
+#if COM_UNITY_MODULES_PHYSICS
+            var rigidBody = GetComponent<Rigidbody>();
+            var ghostRigidBody = GetComponent<GhostRigidbody>();
+            if (rigidBody != null)
+            {
+                // This must be enabled when replicating the rigid body.
+
+                ghostAdapter.SingleWorldHostInterpolationSmoothing = SingleWorldHostInterpolationMode.Interpolate;
+                // TODO: Currently, this is added only if you enable replication of the rigid body.
+                // There is a bug where if you don't add this component it doesn't synchronize the transform.
+                // Remove this once the issue is resolved.
+                if (ghostRigidBody == null)
                 {
-                    // Keep moving until it can't go higher
+                    gameObject.AddComponent<GhostRigidbody>();
                 }
-
-                m_Sorted = true;
             }
+#endif
+#if COM_UNITY_MODULES_PHYSICS2D
+            // TODO: Fill out a similar script as above but for the 2D version
+#endif
         }
 #endif
 
@@ -67,6 +82,11 @@ internal void HybridParentUpdate(Vector3 scale)
             //Debug.Log($"---- New LT: {transform.localPosition} | {transform.localRotation}");
             Ghost.ApplyPostTransformMatrixScale(scale);
         }
+
+        internal void ApplyScale(Vector3 scale)
+        {
+            Ghost.ApplyPostTransformMatrixScale(scale);
+        }
     }
 }
 #endif

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

@@ -370,17 +370,38 @@ private void CheckForInScenePlaced()
         [SerializeField]
         internal bool HadBridge;
 #if UNITY_EDITOR
+        private void OnApplicationUpdate()
+        {
+            NetworkObjectBridge = gameObject.AddComponent<NetworkObjectBridge>();
+            HadBridge = true;
+            // Transform synchronization is handled by unified netcode
+            SynchronizeTransform = false;
+
+            EditorApplication.update -= OnApplicationUpdate;
+        }
+
         internal void UnifiedValidation()
         {
             NetworkObjectBridge = GetComponent<NetworkObjectBridge>();
             GhostAdapter = GetComponent<GhostAdapter>();
+
             HasGhost = GhostAdapter != null;
-            if (HasGhost && NetworkObjectBridge == null)
+            if (HasGhost)
             {
-                NetworkObjectBridge = gameObject.AddComponent<NetworkObjectBridge>();
-                HadBridge = true;
-                // Transform synchronization is handled by unified netcode
-                SynchronizeTransform = false;
+                //TODO: Needs to be validated once develop-2.0.0 is merged.
+                if (InScenePlaced)
+                {
+                    Debug.LogError($"This experimental version of NGO does not support hybrid in-scene placed objects.");
+                    Destroy(GhostAdapter);
+                    HasGhost = false;
+                    return;
+                }
+
+                if (NetworkObjectBridge == null)
+                {
+                    EditorApplication.update -= OnApplicationUpdate;
+                    EditorApplication.update += OnApplicationUpdate;
+                }
             }
             else if (HadBridge && !HasGhost && !NetworkObjectBridge)
             {
@@ -389,6 +410,14 @@ internal void UnifiedValidation()
             }
         }
 #endif
+
+        public void ApplyScale(Vector3 scale)
+        {
+            if (HasGhost)
+            {
+                GhostAdapter.ApplyPostTransformMatrixScale(scale);
+            }
+        }
 #endif
         /// <summary>
         /// Gets the NetworkManager that owns this NetworkObject instance
@@ -2856,33 +2885,53 @@ internal bool InitializeChildNetworkBehaviours()
 #endif
             }
 #if UNIFIED_NETCODE
-            // For now, cycle through all known NetworkTransform and NetworkRigidbodyBase derived components
+            // For now, cycle through all known NetworkRigidbodyBase derived components
             // and destroy them all if this is a hybrid prefab instance.
             // This allows a user to not have to make direct adjustments until trying out their NGO prefab
-            // as a hybrid spawned prefab (optional to completely remove, will eventually become obsolete and
-            // automatically removed later).
+            // as a hybrid spawned prefab.
             if (HasGhost && !NetworkManager.DistributedAuthorityMode)
             {
+#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
+                // TODO-UNIFIED: This needs to be updated to make it "opt-in".
+                // If the GhostAdapter is not configured for prediction but is still using a Rigidbody, then go ahead and remove it on
+                // the client side to improve performance by default.
+                // TODO-UNIFIED: Determine if recent unified physics updates does not require checking for prediction.
                 if (NetworkRigidbodies != null)
                 {
+                    var isServer = NetworkManager.IsServer;
                     for (int i = NetworkRigidbodies.Count - 1; i >= 0; i--)
                     {
-                        // TODO-UNIFIED: This needs to be updated to make it "opt-in".
-                        // Only clients remove the rigidbody for performance purposes when running a hybrid spawn client-server topology.
-                        if (!NetworkManager.IsServer)
+                        var currenObject = NetworkRigidbodies[i].gameObject;
+                        var currentHasGhostRigidBody = currenObject.GetComponent<GhostRigidbody>() != null;
+                        if (!isServer)
                         {
-                            var rigidBody = NetworkRigidbodies[i].gameObject.GetComponent<Rigidbody>();
-                            if (rigidBody != null)
+#if COM_UNITY_MODULES_PHYSICS
+                            var rigidBody = currenObject.GetComponent<Rigidbody>();
+
+                            if (rigidBody != null && !currentHasGhostRigidBody)
                             {
                                 Destroy(rigidBody);
                             }
+#endif
+#if COM_UNITY_MODULES_PHYSICS2D
+                            var rigidBody2D = currenObject.GetComponent<Rigidbody2D>();
+                            if (rigidBody2D != null && !currentHasGhostRigidBody)
+                            {
+                                Destroy(rigidBody2D);
+                            }
+#endif
                         }
-                        ChildNetworkBehaviours.Remove(NetworkRigidbodies[i].NetworkBehaviourId);
-                        Destroy(NetworkRigidbodies[i]);
+                        // Both the server and clients will still remove and destroy the NetworkRigidbody
+                        // since there is no point in synchronizing these when it is handled via unified.
+                        var networkRigidbody = NetworkRigidbodies[i];
+                        NetworkRigidbodies.Remove(networkRigidbody);
+                        ChildNetworkBehaviours.Remove(networkRigidbody.NetworkBehaviourId);
+                        Destroy(networkRigidbody);
                     }
-                    NetworkRigidbodies.Clear();
                 }
-
+#endif
+                // This is defined out since users might have derived NetworkTransforms
+#if UNIFIED_NETCODE_DESTROY
                 // When hybrid spawning, the transform is synchronized by the GhostObject.
                 // As a convenience, we remove and destroy all NetworkTransforms.
                 // TODO-Parenting-Related-Area: We need to replicate this functionality in a GhostAdapter
@@ -2898,6 +2947,7 @@ internal bool InitializeChildNetworkBehaviours()
                     }
                     NetworkTransforms.Clear();
                 }
+#endif
             }
 #endif
             return true;