update

Reverted the change in HiddenScriptEditor.
Moved away from a NetworkAnimator custom editor to a custom property drawer to handle displaying the Animator parameters to be synchronized.
Handling the population of parameters and populating the NetworkAnimator.AnimatorParameterEntries during OnValidate.
Had to re-apply unchecking the excluded parameter in some prefabs for testing purposes.

Author: NoelStephensUnity

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

@@ -155,11 +155,11 @@ public override void OnInspectorGUI()
     /// <summary>
     /// Internal use. Hides the script field for NetworkAnimator.
     /// </summary>
-    //[CustomEditor(typeof(NetworkAnimator), true)]
-    //public class NetworkAnimatorEditor : HiddenScriptEditor
-    //{
+    [CustomEditor(typeof(NetworkAnimator), true)]
+    public class NetworkAnimatorEditor : HiddenScriptEditor
+    {
 
-    //}
+    }
 #endif
 
 #if COM_UNITY_MODULES_PHYSICS

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

@@ -0,0 +1,97 @@
+
+using Unity.Netcode.Components;
+using UnityEditor;
+//using UnityEditor.UIElements;
+//using UnityEngine.UIElements;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor
+{
+    [CustomPropertyDrawer(typeof(NetworkAnimator.AnimatorParametersListContainer))]
+    internal class NetworkAnimatorParameterEntryEditor : PropertyDrawer
+    {
+        // Draw the property inside the given rect
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.BeginProperty(position, label, property);
+
+            // Draw the foldout for the list
+            SerializedProperty items = property.FindPropertyRelative(nameof(NetworkAnimator.AnimatorParameterEntries.ParameterEntries));
+            position.height = EditorGUIUtility.singleLineHeight;
+            property.isExpanded = EditorGUI.Foldout(position, property.isExpanded, label);
+
+            if (property.isExpanded)
+            {
+                // Set the indention level down
+                EditorGUI.indentLevel++;
+                for (int i = 0; i < items.arraySize; i++)
+                {
+                    position.y += EditorGUIUtility.singleLineHeight + 2;
+                    SerializedProperty element = items.GetArrayElementAtIndex(i);
+                    var nameField = element.FindPropertyRelative(nameof(NetworkAnimator.AnimatorParameterEntry.name));
+                    // Draw the foldout for the item
+                    element.isExpanded = EditorGUI.Foldout(position, element.isExpanded, nameField.stringValue);
+                    if (!element.isExpanded)
+                    {
+                        continue;
+                    }
+                    // Draw the contents of the item
+                    position.y += EditorGUIUtility.singleLineHeight + 2;
+                    // Set the indention level down
+                    EditorGUI.indentLevel++;
+                    // Calculate rects
+                    var nameHashRect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight);
+                    position.y += EditorGUIUtility.singleLineHeight + 2;
+                    var paramRect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight);
+                    position.y += EditorGUIUtility.singleLineHeight + 2;
+                    var syncRect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight);
+
+                    // Get the three properties we want to visualize in the inspector view
+                    var synchronizeField = element.FindPropertyRelative(nameof(NetworkAnimator.AnimatorParameterEntry.Synchronize));
+                    var nameHashField = element.FindPropertyRelative(nameof(NetworkAnimator.AnimatorParameterEntry.NameHash));
+                    var parameterTypeField = element.FindPropertyRelative(nameof(NetworkAnimator.AnimatorParameterEntry.ParameterType));
+
+                    // Draw the read only fields
+                    GUI.enabled = false;
+                    EditorGUI.PropertyField(nameHashRect, nameHashField);
+                    EditorGUI.PropertyField(paramRect, parameterTypeField);
+                    GUI.enabled = true;
+                    // Draw the read/write fields
+                    EditorGUI.PropertyField(syncRect, synchronizeField);
+                    // Set the indention level up
+                    EditorGUI.indentLevel--;
+                }
+                // Set the indention level up
+                EditorGUI.indentLevel--;
+            }
+            EditorGUI.EndProperty();
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            var totalHeight = EditorGUIUtility.singleLineHeight;
+            if (!property.isExpanded)
+            {
+                return totalHeight;
+            }
+            var singleLineWithSpace = EditorGUIUtility.singleLineHeight + 2;
+            SerializedProperty items = property.FindPropertyRelative(nameof(NetworkAnimator.AnimatorParameterEntries.ParameterEntries));
+
+            totalHeight += singleLineWithSpace;
+            for (int i = 0; i < items.arraySize; i++)
+            {
+                SerializedProperty element = items.GetArrayElementAtIndex(i);
+                if (element.isExpanded)
+                {
+                    totalHeight += (singleLineWithSpace * 4);
+                }
+                else
+                {
+                    totalHeight += EditorGUIUtility.singleLineHeight;
+                }
+            }
+            return totalHeight;
+        }
+    }
+}
+

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

@@ -249,6 +249,21 @@ public enum AuthorityModes
 #endif
         public AuthorityModes AuthorityMode;
 
+        [Tooltip("The animator that this NetworkAnimator component will be synchronizing.")]
+        [SerializeField] private Animator m_Animator;
+
+        /// <summary>
+        /// The <see cref="Animator"/> associated with this <see cref="NetworkAnimator"/> instance.
+        /// </summary>
+        public Animator Animator
+        {
+            get { return m_Animator; }
+            set
+            {
+                m_Animator = value;
+            }
+        }
+
         /// <summary>
         /// Used to build the destination state to transition info table
         /// </summary>
@@ -282,31 +297,33 @@ private void BuildDestinationToTransitionInfoTable()
         [Serializable]
         internal class AnimatorParameterEntry
         {
-            public bool Synchronize;
+#pragma warning disable IDE1006
+            [HideInInspector]
+            public string name;
+#pragma warning restore IDE1006
             public int NameHash;
-            public string Name;
+            public bool Synchronize;
             public AnimatorControllerParameterType ParameterType;
-#if UNITY_EDITOR
-            public AnimatorParameterEntry(AnimatorControllerParameter parameter)
-            {
-                Synchronize = true;
-                NameHash = parameter.nameHash;
-                Name = parameter.name;
-                ParameterType = parameter.type;
-            }
-#endif
-            public AnimatorParameterEntry() { }
         }
 
-        [HideInInspector]
+        [Serializable]
+        internal class AnimatorParametersListContainer
+        {
+            public List<AnimatorParameterEntry> ParameterEntries = new List<AnimatorParameterEntry>();
+        }
+
         [SerializeField]
-        internal List<AnimatorParameterEntry> AnimatorParameterEntries;
+        internal AnimatorParametersListContainer AnimatorParameterEntries;
 
         internal Dictionary<int, AnimatorParameterEntry> AnimatorParameterEntryTable = new Dictionary<int, AnimatorParameterEntry>();
 
 #if UNITY_EDITOR
+        [HideInInspector]
+        [SerializeField]
         internal bool AnimatorParametersExpanded;
 
+        internal Dictionary<int, AnimatorControllerParameter> ParameterToNameLookup = new Dictionary<int, AnimatorControllerParameter>();
+
         private void ParseStateMachineStates(int layerIndex, ref AnimatorController animatorController, ref AnimatorStateMachine stateMachine)
         {
             for (int y = 0; y < stateMachine.states.Length; y++)
@@ -397,13 +414,81 @@ private void BuildTransitionStateInfoList()
             }
         }
 
+        internal void ProcessParameterEntries()
+        {
+            if (!Animator)
+            {
+                if (AnimatorParameterEntries != null && AnimatorParameterEntries.ParameterEntries.Count > 0)
+                {
+                    AnimatorParameterEntries.ParameterEntries.Clear();
+                }
+                return;
+            }
+
+            var parameters = Animator.parameters;
+
+            var parametersToRemove = new List<AnimatorParameterEntry>();
+            ParameterToNameLookup.Clear();
+            foreach (var parameter in parameters)
+            {
+                ParameterToNameLookup.Add(parameter.nameHash, parameter);
+            }
+
+            // Rebuild the parameter entry table for the inspector view
+            AnimatorParameterEntryTable.Clear();
+            foreach (var parameterEntry in AnimatorParameterEntries.ParameterEntries)
+            {
+                // Check for removed parameters.
+                if (!ParameterToNameLookup.ContainsKey(parameterEntry.NameHash))
+                {
+                    parametersToRemove.Add(parameterEntry);
+                    // Skip this removed entry
+                    continue;
+                }
+
+                // Build the list of known parameters
+                if (!AnimatorParameterEntryTable.ContainsKey(parameterEntry.NameHash))
+                {
+                    AnimatorParameterEntryTable.Add(parameterEntry.NameHash, parameterEntry);
+                }
+
+                var parameter = ParameterToNameLookup[parameterEntry.NameHash];
+                parameterEntry.name = parameter.name;
+                parameterEntry.ParameterType = parameter.type;
+            }
+
+            // Update for removed parameters
+            foreach (var parameterEntry in parametersToRemove)
+            {
+                AnimatorParameterEntries.ParameterEntries.Remove(parameterEntry);
+            }
+
+            // Update any newly added parameters
+            foreach (var parameterLookUp in ParameterToNameLookup)
+            {
+                if (!AnimatorParameterEntryTable.ContainsKey(parameterLookUp.Value.nameHash))
+                {
+                    var animatorParameterEntry = new AnimatorParameterEntry()
+                    {
+                        name = parameterLookUp.Value.name,
+                        NameHash = parameterLookUp.Value.nameHash,
+                        ParameterType = parameterLookUp.Value.type,
+                        Synchronize = true,
+                    };
+                    AnimatorParameterEntries.ParameterEntries.Add(animatorParameterEntry);
+                    AnimatorParameterEntryTable.Add(parameterLookUp.Value.nameHash, animatorParameterEntry);
+                }
+            }
+        }
+
         /// <summary>
         /// In-Editor Only
         /// Virtual OnValidate method for custom derived NetworkAnimator classes.
         /// </summary>
         protected virtual void OnValidate()
         {
             BuildTransitionStateInfoList();
+            ProcessParameterEntries();
         }
 #endif
 
@@ -557,21 +642,6 @@ public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReade
             }
         }
 
-        [Tooltip("The animator that this NetworkAnimator component will be synchronizing.")]
-        [SerializeField] private Animator m_Animator;
-
-        /// <summary>
-        /// The <see cref="Animator"/> associated with this <see cref="NetworkAnimator"/> instance.
-        /// </summary>
-        public Animator Animator
-        {
-            get { return m_Animator; }
-            set
-            {
-                m_Animator = value;
-            }
-        }
-
         /// <summary>
         /// Determines whether the <see cref="NetworkAnimator"/> is <see cref="AuthorityModes.Server"/> or <see cref="AuthorityModes.Owner"/> based on the <see cref="AuthorityMode"/> field.
         /// Optionally, you can still derive from <see cref="NetworkAnimator"/> and override the <see cref="OnIsServerAuthoritative"/> method.
@@ -679,7 +749,7 @@ protected virtual void Awake()
                 return;
             }
 
-            foreach (var parameterEntry in AnimatorParameterEntries)
+            foreach (var parameterEntry in AnimatorParameterEntries.ParameterEntries)
             {
                 if (!AnimatorParameterEntryTable.ContainsKey(parameterEntry.NameHash))
                 {