update

NetworkRigidbodyBase and NetworkTransform classes are destroyed during runtime initialization of a prefab instance if they still remain and the instance is a hybrid prefab instance (i.e. unified handles transform synchronization and physics related stuff).

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Runtime/Components/NetworkRigidBodyBase.cs

@@ -193,6 +193,11 @@ protected void Initialize(RigidbodyTypes rigidbodyType, NetworkTransform network
 #endif
 
 #if COM_UNITY_MODULES_PHYSICS && COM_UNITY_MODULES_PHYSICS2D
+#if UNIFIED_NETCODE
+        // Used to keep track of the original kinematic state upon awake.
+        // (see OnDestroy below)
+        private bool m_OriginalKinematicState;
+#endif
         /// <summary>
         /// Initializes the networked Rigidbody based on the <see cref="RigidbodyTypes"/>
         /// passed in as a parameter.
@@ -246,9 +251,31 @@ protected void Initialize(RigidbodyTypes rigidbodyType, NetworkTransform network
 
             if (AutoUpdateKinematicState)
             {
+#if UNIFIED_NETCODE
+                // Keep track of the original kinematic state. (see OnDestroy)
+                m_OriginalKinematicState = IsKinematic();
+#endif
                 SetIsKinematic(true);
             }
         }
+
+#if UNIFIED_NETCODE
+        public override void OnDestroy()
+        {
+            base.OnDestroy();
+            // If the user has left this component on their prefab and this is a hybrid prefab,
+            // then we want to set the rigid body back to its original kinematic settings since
+            // we are automatically destroying these components at runtime when it is a hybrid
+            // prefab that is spawned.
+            if (NetworkObject && NetworkObject.HasGhost)
+            {
+                if (m_InternalRigidbody || m_InternalRigidbody2D)
+                {
+                    SetIsKinematic(m_OriginalKinematicState);
+                }
+            }
+        }
+#endif
 #endif
         internal Vector3 GetAdjustedPositionThreshold()
         {

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

@@ -368,6 +368,8 @@ private void UnifiedValidation()
                 {
                     NetworkObjectBridge = gameObject.AddComponent<NetworkObjectBridge>();
                     HadBridge = true;
+                    // Transform synchronization is handled by unified netcode
+                    SynchronizeTransform = false;
                 }
             }
         }
@@ -2696,35 +2698,78 @@ internal List<NetworkBehaviour> ChildNetworkBehaviours
                     {
                         continue;
                     }
-
-                    // Set ourselves as the NetworkObject that this behaviour belongs to and add it to the child list
-                    var nextIndex = (ushort)m_ChildNetworkBehaviours.Count;
-                    networkBehaviours[i].SetNetworkObject(this, nextIndex);
-                    m_ChildNetworkBehaviours.Add(networkBehaviours[i]);
-
                     var type = networkBehaviours[i].GetType();
+#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
+                    if (type.IsSubclassOf(typeof(NetworkRigidbodyBase)))
+                    {
+                        var networkRigidbody = networkBehaviours[i] as NetworkRigidbodyBase;
+
+                        if (NetworkRigidbodies == null)
+                        {
+                            NetworkRigidbodies = new List<NetworkRigidbodyBase>();
+                        }
+                        NetworkRigidbodies.Add(networkRigidbody);
+#if UNIFIED_NETCODE
+                        // For now, we will just destroy these components during runtime since they will not
+                        // be supported in hybrid mode (don't add to the children).
+                        if (HasGhost)
+                        {
+                            continue;
+                        }
+#endif
+                    }
+                    else
+#endif
                     if (type == typeof(NetworkTransform) || type.IsInstanceOfType(typeof(NetworkTransform)) || type.IsSubclassOf(typeof(NetworkTransform)))
                     {
+                        var networkTransform = networkBehaviours[i] as NetworkTransform;
+
                         if (NetworkTransforms == null)
                         {
                             NetworkTransforms = new List<NetworkTransform>();
                         }
-                        var networkTransform = networkBehaviours[i] as NetworkTransform;
+
                         networkTransform.IsNested = i != 0 && networkTransform.gameObject != gameObject;
                         NetworkTransforms.Add(networkTransform);
-                    }
-#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
-                    else if (type.IsSubclassOf(typeof(NetworkRigidbodyBase)))
-                    {
-                        if (NetworkRigidbodies == null)
+#if UNIFIED_NETCODE
+                        // For now, we will just destroy these components during runtime since they will not
+                        // be supported in hybrid mode (don't add to the children).
+                        if (HasGhost)
                         {
-                            NetworkRigidbodies = new List<NetworkRigidbodyBase>();
+                            continue;
                         }
-                        NetworkRigidbodies.Add(networkBehaviours[i] as NetworkRigidbodyBase);
-                    }
 #endif
+                    }
+
+                    // Set ourselves as the NetworkObject that this behaviour belongs to and add it to the child list
+                    var nextIndex = (ushort)m_ChildNetworkBehaviours.Count;
+                    networkBehaviours[i].SetNetworkObject(this, nextIndex);
+
+                    // Finally, add the NetworkBehaviour to the list of child NetworkBehaviours
+                    m_ChildNetworkBehaviours.Add(networkBehaviours[i]);
                 }
 
+#if UNIFIED_NETCODE
+                // For now, cycle through all known NetworkTransform and 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).
+                if (HasGhost)
+                {
+                    for (int i = NetworkRigidbodies.Count - 1; i >= 0; i--)
+                    {
+                        Destroy(NetworkRigidbodies[i]);
+                    }
+                    for (int i = NetworkTransforms.Count - 1; i >= 0; i--)
+                    {
+                        Destroy(NetworkTransforms[i]);
+                    }
+                    NetworkRigidbodies.Clear();
+                    NetworkTransforms.Clear();
+                }
+#endif
+
                 return m_ChildNetworkBehaviours;
             }
         }
@@ -3572,7 +3617,7 @@ private void Start()
                 Debug.LogWarning($"[{nameof(NetworkObject)}][{name}] Was not enabled on start! Enabling.");
                 enabled = true;
             }
-            
+
             InitGhost();
         }
         [SerializeField]