fix: weighted layer support in NetworkAnimator MTT-2698 (#1765)

* fix: weighted layer support in NetworkAnimator MTT-2698
* more integration tests

Author: mattwalsh-unity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -9,8 +9,8 @@ Additional documentation and release notes are available at [Multiplayer Documen
 ## [Unreleased]
 
 ### Added
-
-- Added first set of tests for NetworkAnimator - parameter syncing, trigger set / reset, override network animator (#7135)
+- NetworkAnimator now properly synchrhonizes all animation layers as well as runtime-adjusted weighting between them (#1765)
+- Added first set of tests for NetworkAnimator - parameter syncing, trigger set / reset, override network animator (#1735)
 
 ### Changed
 

com.unity.netcode.gameobjects/Components/NetworkAnimator.cs

@@ -1,6 +1,5 @@
 using Unity.Collections;
 using Unity.Collections.LowLevel.Unsafe;
-
 using UnityEngine;
 
 namespace Unity.Netcode.Components
@@ -14,14 +13,19 @@ public class NetworkAnimator : NetworkBehaviour
     {
         internal struct AnimationMessage : INetworkSerializable
         {
-            public int StateHash;      // if non-zero, then Play() this animation, skipping transitions
+            // state hash per layer.  if non-zero, then Play() this animation, skipping transitions
+            public int StateHash;
             public float NormalizedTime;
+            public int Layer;
+            public float Weight;
             public byte[] Parameters;
 
             public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
                 serializer.SerializeValue(ref StateHash);
                 serializer.SerializeValue(ref NormalizedTime);
+                serializer.SerializeValue(ref Layer);
+                serializer.SerializeValue(ref Weight);
                 serializer.SerializeValue(ref Parameters);
             }
         }
@@ -54,10 +58,9 @@ public Animator Animator
         // Animators only support up to 32 params
         public static int K_MaxAnimationParams = 32;
 
-        private int m_TransitionHash;
-
-        private int m_AnimationHash;
-        public int AnimationHash { get => m_AnimationHash; }
+        private int[] m_TransitionHash;
+        private int[] m_AnimationHash;
+        private float[] m_LayerWeights;
 
         private unsafe struct AnimatorParamCache
         {
@@ -100,12 +103,16 @@ public override void OnNetworkSpawn()
             if (IsServer)
             {
                 m_SendMessagesAllowed = true;
+                int layers = m_Animator.layerCount;
+
+                m_TransitionHash = new int[layers];
+                m_AnimationHash = new int[layers];
+                m_LayerWeights = new float[layers];
             }
+
             var parameters = m_Animator.parameters;
             m_CachedAnimatorParameters = new NativeArray<AnimatorParamCache>(parameters.Length, Allocator.Persistent);
 
-            m_AnimationHash = -1;
-
             for (var i = 0; i < parameters.Length; i++)
             {
                 var parameter = parameters[i];
@@ -157,66 +164,81 @@ public override void OnNetworkDespawn()
 
         private void FixedUpdate()
         {
-            if (!m_SendMessagesAllowed)
+            if (!m_SendMessagesAllowed || !m_Animator || !m_Animator.enabled)
             {
                 return;
             }
 
-            int stateHash;
-            float normalizedTime;
-            if (!CheckAnimStateChanged(out stateHash, out normalizedTime))
+            for (int layer = 0; layer < m_Animator.layerCount; layer++)
             {
-                return;
-            }
+                int stateHash;
+                float normalizedTime;
+                if (!CheckAnimStateChanged(out stateHash, out normalizedTime, layer))
+                {
+                    continue;
+                }
 
-            var animMsg = new AnimationMessage
-            {
-                StateHash = stateHash,
-                NormalizedTime = normalizedTime
-            };
+                var animMsg = new AnimationMessage
+                {
+                    StateHash = stateHash,
+                    NormalizedTime = normalizedTime,
+                    Layer = layer,
+                    Weight = m_LayerWeights[layer]
+                };
 
-            m_ParameterWriter.Seek(0);
-            m_ParameterWriter.Truncate();
+                m_ParameterWriter.Seek(0);
+                m_ParameterWriter.Truncate();
 
-            WriteParameters(m_ParameterWriter);
-            animMsg.Parameters = m_ParameterWriter.ToArray();
+                WriteParameters(m_ParameterWriter);
+                animMsg.Parameters = m_ParameterWriter.ToArray();
 
-            SendAnimStateClientRpc(animMsg);
+                SendAnimStateClientRpc(animMsg);
+            }
         }
 
-        private bool CheckAnimStateChanged(out int stateHash, out float normalizedTime)
+        private bool CheckAnimStateChanged(out int stateHash, out float normalizedTime, int layer)
         {
+            bool shouldUpdate = false;
             stateHash = 0;
             normalizedTime = 0;
 
-            if (m_Animator.IsInTransition(0))
+            float layerWeightNow = m_Animator.GetLayerWeight(layer);
+
+            if (!Mathf.Approximately(layerWeightNow, m_LayerWeights[layer]))
+            {
+                m_LayerWeights[layer] = layerWeightNow;
+                shouldUpdate = true;
+            }
+            if (m_Animator.IsInTransition(layer))
             {
-                AnimatorTransitionInfo tt = m_Animator.GetAnimatorTransitionInfo(0);
-                if (tt.fullPathHash != m_TransitionHash)
+                AnimatorTransitionInfo tt = m_Animator.GetAnimatorTransitionInfo(layer);
+                if (tt.fullPathHash != m_TransitionHash[layer])
                 {
-                    // first time in this transition
-                    m_TransitionHash = tt.fullPathHash;
-                    m_AnimationHash = 0;
-                    return true;
+                    // first time in this transition for this layer
+                    m_TransitionHash[layer] = tt.fullPathHash;
+                    m_AnimationHash[layer] = 0;
+                    shouldUpdate = true;
                 }
-                return false;
             }
-
-            AnimatorStateInfo st = m_Animator.GetCurrentAnimatorStateInfo(0);
-            if (st.fullPathHash != m_AnimationHash)
+            else
             {
-                // first time in this animation state
-                if (m_AnimationHash != 0)
+                AnimatorStateInfo st = m_Animator.GetCurrentAnimatorStateInfo(layer);
+                if (st.fullPathHash != m_AnimationHash[layer])
                 {
-                    // came from another animation directly - from Play()
-                    stateHash = st.fullPathHash;
-                    normalizedTime = st.normalizedTime;
+                    // first time in this animation state
+                    if (m_AnimationHash[layer] != 0)
+                    {
+                        // came from another animation directly - from Play()
+                        stateHash = st.fullPathHash;
+                        normalizedTime = st.normalizedTime;
+                    }
+                    m_TransitionHash[layer] = 0;
+                    m_AnimationHash[layer] = st.fullPathHash;
+                    shouldUpdate = true;
                 }
-                m_TransitionHash = 0;
-                m_AnimationHash = st.fullPathHash;
-                return true;
             }
-            return false;
+
+            return shouldUpdate;
         }
 
         /* $AS TODO: Right now we are not checking for changed values this is because
@@ -311,9 +333,9 @@ private unsafe void SendAnimStateClientRpc(AnimationMessage animSnapshot, Client
         {
             if (animSnapshot.StateHash != 0)
             {
-                m_AnimationHash = animSnapshot.StateHash;
-                m_Animator.Play(animSnapshot.StateHash, 0, animSnapshot.NormalizedTime);
+                m_Animator.Play(animSnapshot.StateHash, animSnapshot.Layer, animSnapshot.NormalizedTime);
             }
+            m_Animator.SetLayerWeight(animSnapshot.Layer, animSnapshot.Weight);
 
             if (animSnapshot.Parameters != null && animSnapshot.Parameters.Length != 0)
             {

com.unity.netcode.gameobjects/Tests/Runtime/NetworkAnimator/NetworkAnimatorTests.cs

@@ -129,6 +129,53 @@ public IEnumerator AnimationStateSyncTest()
             Assert.False(s_GloabalTimeoutHelper.TimedOut, "Client failed to sync its animation state from the server");
         }
 
+        [UnityTest]
+        public IEnumerator AnimationLayerStateSyncTest()
+        {
+            int layer = 1;
+            // check that we have started in the default state
+            Assert.True(m_PlayerOnServerAnimator.GetCurrentAnimatorStateInfo(layer).IsName("DefaultStateLayer2"));
+            Assert.True(m_PlayerOnClientAnimator.GetCurrentAnimatorStateInfo(layer).IsName("DefaultStateLayer2"));
+
+            // cause a change to the AlphaState state by setting AlphaParameter, which is
+            //  the variable bound to the transition from default to AlphaState (see the TestAnimatorController asset)
+            m_PlayerOnServerAnimator.SetBool("Layer2AlphaParameter", true);
+
+            // ...and now we should be in the AlphaState having triggered the AlphaParameter
+            yield return WaitForConditionOrTimeOut(() => m_PlayerOnServerAnimator.GetCurrentAnimatorStateInfo(layer).IsName("Layer2AlphaState"));
+            Assert.False(s_GloabalTimeoutHelper.TimedOut, "Server failed to reach its animation state");
+
+            // ...and now the client should also have sync'd and arrived at the correct state
+            yield return WaitForConditionOrTimeOut(() => m_PlayerOnClientAnimator.GetCurrentAnimatorStateInfo(layer).IsName("Layer2AlphaState"));
+            Assert.False(s_GloabalTimeoutHelper.TimedOut, "Client failed to sync its animation state from the server");
+        }
+
+        [UnityTest]
+        public IEnumerator AnimationLayerWeightTest()
+        {
+            int layer = 1;
+            float targetWeight = 0.333f;
+
+            // check that we have started in the default state
+            Assert.True(Mathf.Approximately(m_PlayerOnServerAnimator.GetLayerWeight(layer), 1f));
+            Assert.True(Mathf.Approximately(m_PlayerOnClientAnimator.GetLayerWeight(layer), 1f));
+
+            m_PlayerOnServerAnimator.SetLayerWeight(layer, targetWeight);
+
+            // ...and now we should be in the AlphaState having triggered the AlphaParameter
+            yield return WaitForConditionOrTimeOut(() =>
+                Mathf.Approximately(m_PlayerOnServerAnimator.GetLayerWeight(layer), targetWeight)
+            );
+            Assert.False(s_GloabalTimeoutHelper.TimedOut, "Server failed to reach its animation state");
+
+            // ...and now the client should also have sync'd and arrived at the correct state
+            yield return WaitForConditionOrTimeOut(() =>
+                Mathf.Approximately(m_PlayerOnClientAnimator.GetLayerWeight(layer), targetWeight)
+            );
+            Assert.False(s_GloabalTimeoutHelper.TimedOut, "Server failed to reach its animation state");
+        }
+
+
         [UnityTest]
         public IEnumerator AnimationStateSyncTriggerTest([Values(true, false)] bool asHash)
         {

com.unity.netcode.gameobjects/Tests/Runtime/NetworkAnimator/Resources/Layer2Animation.anim

@@ -0,0 +1,53 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!74 &7400000
+AnimationClip:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Layer2Animation
+  serializedVersion: 6
+  m_Legacy: 0
+  m_Compressed: 0
+  m_UseHighQualityCurve: 1
+  m_RotationCurves: []
+  m_CompressedRotationCurves: []
+  m_EulerCurves: []
+  m_PositionCurves: []
+  m_ScaleCurves: []
+  m_FloatCurves: []
+  m_PPtrCurves: []
+  m_SampleRate: 60
+  m_WrapMode: 0
+  m_Bounds:
+    m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 0, y: 0, z: 0}
+  m_ClipBindingConstant:
+    genericBindings: []
+    pptrCurveMapping: []
+  m_AnimationClipSettings:
+    serializedVersion: 2
+    m_AdditiveReferencePoseClip: {fileID: 0}
+    m_AdditiveReferencePoseTime: 0
+    m_StartTime: 0
+    m_StopTime: 1
+    m_OrientationOffsetY: 0
+    m_Level: 0
+    m_CycleOffset: 0
+    m_HasAdditiveReferencePose: 0
+    m_LoopTime: 0
+    m_LoopBlend: 0
+    m_LoopBlendOrientation: 0
+    m_LoopBlendPositionY: 0
+    m_LoopBlendPositionXZ: 0
+    m_KeepOriginalOrientation: 0
+    m_KeepOriginalPositionY: 1
+    m_KeepOriginalPositionXZ: 0
+    m_HeightFromFeet: 0
+    m_Mirror: 0
+  m_EditorCurves: []
+  m_EulerEditorCurves: []
+  m_HasGenericRootTransform: 0
+  m_HasMotionFloatCurves: 0
+  m_Events: []