Reworked NetworkedAnimator

TwoTenPvP · TwoTenPvP · commit 0f083182242f · 2018-03-05T20:25:08.000+01:00
diff --git a/MLAPI/MonoBehaviours/Prototyping/NetworkedAnimator.cs b/MLAPI/MonoBehaviours/Prototyping/NetworkedAnimator.cs
@@ -1,27 +1,36 @@
-﻿using System;
-using System.IO;
+﻿using System.IO;
 using UnityEngine;
 
 namespace MLAPI
 {
-    [DisallowMultipleComponent]
-    [RequireComponent(typeof(Animator))]
     public class NetworkedAnimator : NetworkedBehaviour
     {
-        // configuration
-        [SerializeField] Animator   m_Animator;
-        [SerializeField] uint       m_ParameterSendBits;
-        [SerializeField] float m_SendRate = 0.1f;
+        [SerializeField]
+        private Animator _animator;
+        [SerializeField]
+        private uint parameterSendBits;
+        [SerializeField]
+        private float sendRate = 0.1f;
+        private AnimatorControllerParameter[] animatorParameters;
+
+        private int animationHash;
+        private int transitionHash;
+        private float sendTimer;
+
+        // tracking - these should probably move to a Preview component. -- Comment from HLAPI. Needs clarification
+        public string param0;
+        public string param1;
+        public string param2;
+        public string param3;
+        public string param4;
+        public string param5;
 
-        AnimatorControllerParameter[] m_AnimatorParameters;
-
-        // properties
         public Animator animator
         {
-            get { return m_Animator; }
+            get { return _animator; }
             set
             {
-                m_Animator = value;
+                _animator = value;
                 ResetParameterOptions();
             }
         }
@@ -30,32 +39,20 @@ public void SetParameterAutoSend(int index, bool value)
         {
             if (value)
             {
-                m_ParameterSendBits |=  (uint)(1 << index);
+                parameterSendBits |=  (uint)(1 << index);
             }
             else
             {
-                m_ParameterSendBits &= (uint)(~(1 << index));
+                parameterSendBits &= (uint)(~(1 << index));
             }
         }
 
         public bool GetParameterAutoSend(int index)
         {
-            return (m_ParameterSendBits & (uint)(1 << index)) != 0;
+            return (parameterSendBits & (uint)(1 << index)) != 0;
         }
 
-        int                     m_AnimationHash;
-        int                     m_TransitionHash;
-        float                   m_SendTimer;
-
-        // tracking - these should probably move to a Preview component.
-        public string   param0;
-        public string   param1;
-        public string   param2;
-        public string   param3;
-        public string   param4;
-        public string   param5;
-
-        bool sendMessagesAllowed
+        private bool sendMessagesAllowed
         {
             get
             {
@@ -73,23 +70,22 @@ public override void NetworkStart()
         public void ResetParameterOptions()
         {
             Debug.Log("ResetParameterOptions");
-            m_ParameterSendBits = 0;
-            m_AnimatorParameters = null;
+            parameterSendBits = 0;
+            animatorParameters = null;
         }
 
-        void FixedUpdate()
+        private void FixedUpdate()
         {
             if (!sendMessagesAllowed)
                 return;
 
             CheckSendRate();
 
-            int stateHash;
-            float normalizedTime;
-            if (!CheckAnimStateChanged(out stateHash, out normalizedTime))
+            if (!CheckAnimStateChanged(out int stateHash, out float normalizedTime))
             {
                 return;
             }
+
             using(MemoryStream stream = new MemoryStream())
             {
                 using (BinaryWriter writer = new BinaryWriter(stream))
@@ -109,46 +105,46 @@ void FixedUpdate()
             }
         }
 
-        bool CheckAnimStateChanged(out int stateHash, out float normalizedTime)
+        private bool CheckAnimStateChanged(out int stateHash, out float normalizedTime)
         {
             stateHash = 0;
             normalizedTime = 0;
 
-            if (m_Animator.IsInTransition(0))
+            if (animator.IsInTransition(0))
             {
-                AnimatorTransitionInfo tt = m_Animator.GetAnimatorTransitionInfo(0);
-                if (tt.fullPathHash != m_TransitionHash)
+                AnimatorTransitionInfo animationTransitionInfo = animator.GetAnimatorTransitionInfo(0);
+                if (animationTransitionInfo.fullPathHash != transitionHash)
                 {
                     // first time in this transition
-                    m_TransitionHash = tt.fullPathHash;
-                    m_AnimationHash = 0;
+                    transitionHash = animationTransitionInfo.fullPathHash;
+                    animationHash = 0;
                     return true;
                 }
                 return false;
             }
 
-            AnimatorStateInfo st = m_Animator.GetCurrentAnimatorStateInfo(0);
-            if (st.fullPathHash != m_AnimationHash)
+            AnimatorStateInfo animationSateInfo = animator.GetCurrentAnimatorStateInfo(0);
+            if (animationSateInfo.fullPathHash != animationHash)
             {
                 // first time in this animation state
-                if (m_AnimationHash != 0)
+                if (animationHash != 0)
                 {
                     // came from another animation directly - from Play()
-                    stateHash = st.fullPathHash;
-                    normalizedTime = st.normalizedTime;
+                    stateHash = animationSateInfo.fullPathHash;
+                    normalizedTime = animationSateInfo.normalizedTime;
                 }
-                m_TransitionHash = 0;
-                m_AnimationHash = st.fullPathHash;
+                transitionHash = 0;
+                animationHash = animationSateInfo.fullPathHash;
                 return true;
             }
             return false;
         }
 
-        void CheckSendRate()
+        private void CheckSendRate()
         {
-            if (sendMessagesAllowed && m_SendRate != 0 && m_SendTimer < Time.time)
+            if (sendMessagesAllowed && sendRate != 0 && sendTimer < Time.time)
             {
-                m_SendTimer = Time.time + m_SendRate;
+                sendTimer = Time.time + sendRate;
 
                 using(MemoryStream stream = new MemoryStream())
                 {
@@ -168,7 +164,7 @@ void CheckSendRate()
             }
         }
 
-        void SetSendTrackingParam(string p, int i)
+        private void SetSendTrackingParam(string p, int i)
         {
             p = "Sent Param: " + p;
             if (i == 0) param0 = p;
@@ -179,7 +175,7 @@ void SetSendTrackingParam(string p, int i)
             if (i == 5) param5 = p;
         }
 
-        void SetRecvTrackingParam(string p, int i)
+        private void SetRecvTrackingParam(string p, int i)
         {
             p = "Recv Param: " + p;
             if (i == 0) param0 = p;
@@ -190,13 +186,12 @@ void SetRecvTrackingParam(string p, int i)
             if (i == 5) param5 = p;
         }
 
-        internal void HandleAnimMsg(int clientId, byte[] data)
+        private void HandleAnimMsg(int clientId, byte[] data)
         {
             // usually transitions will be triggered by parameters, if not, play anims directly.
             // NOTE: this plays "animations", not transitions, so any transitions will be skipped.
             // NOTE: there is no API to play a transition(?)
 
-            //isServer AND the message is not from ourselves. This prevents a stack overflow. Infinite call to itself.
             if(isServer)
             {
                 SendToNonLocalClientsTarget("MLAPI_HandleAnimationMessage", "MLAPI_ANIMATION_UPDATE", data, true);
@@ -209,14 +204,14 @@ internal void HandleAnimMsg(int clientId, byte[] data)
                     float normalizedTime = reader.ReadSingle();
                     if(stateHash != 0)
                     {
-                        m_Animator.Play(stateHash, 0, normalizedTime);
+                        animator.Play(stateHash, 0, normalizedTime);
                     }
                     ReadParameters(reader, false);
                 }
             }
         }
 
-        internal void HandleAnimParamsMsg(int clientId, byte[] data)
+        private void HandleAnimParamsMsg(int clientId, byte[] data)
         {
             if (isServer)
             {
@@ -231,7 +226,7 @@ internal void HandleAnimParamsMsg(int clientId, byte[] data)
             }
         }
 
-        internal void HandleAnimTriggerMsg(int clientId, byte[] data)
+        private void HandleAnimTriggerMsg(int clientId, byte[] data)
         {
             if (isServer)
             {
@@ -241,72 +236,76 @@ internal void HandleAnimTriggerMsg(int clientId, byte[] data)
             {
                 using(BinaryReader reader = new BinaryReader(stream))
                 {
-                    m_Animator.SetTrigger(reader.ReadInt32());
+                    animator.SetTrigger(reader.ReadInt32());
                 }
             }
         }
 
-        void WriteParameters(BinaryWriter writer, bool autoSend)
+        private void WriteParameters(BinaryWriter writer, bool autoSend)
         {
-            if (m_AnimatorParameters == null) m_AnimatorParameters = m_Animator.parameters;
-            for (int i = 0; i < m_AnimatorParameters.Length; i++)
+            if (animatorParameters == null)       
+                animatorParameters = animator.parameters;
+
+            for (int i = 0; i < animatorParameters.Length; i++)
             {
                 if (autoSend && !GetParameterAutoSend(i))
                     continue;
 
-                AnimatorControllerParameter par = m_AnimatorParameters[i];
+                AnimatorControllerParameter par = animatorParameters[i];
                 if (par.type == AnimatorControllerParameterType.Int)
                 {
-                    writer.Write((uint)m_Animator.GetInteger(par.nameHash));
+                    writer.Write((uint)animator.GetInteger(par.nameHash));
 
-                    SetSendTrackingParam(par.name + ":" + m_Animator.GetInteger(par.nameHash), i);
+                    SetSendTrackingParam(par.name + ":" + animator.GetInteger(par.nameHash), i);
                 }
 
                 if (par.type == AnimatorControllerParameterType.Float)
                 {
-                    writer.Write(m_Animator.GetFloat(par.nameHash));
+                    writer.Write(animator.GetFloat(par.nameHash));
 
-                    SetSendTrackingParam(par.name + ":" + m_Animator.GetFloat(par.nameHash), i);
+                    SetSendTrackingParam(par.name + ":" + animator.GetFloat(par.nameHash), i);
                 }
 
                 if (par.type == AnimatorControllerParameterType.Bool)
                 {
-                    writer.Write(m_Animator.GetBool(par.nameHash));
+                    writer.Write(animator.GetBool(par.nameHash));
 
-                    SetSendTrackingParam(par.name + ":" + m_Animator.GetBool(par.nameHash), i);
+                    SetSendTrackingParam(par.name + ":" + animator.GetBool(par.nameHash), i);
                 }
             }
         }
 
-        void ReadParameters(BinaryReader reader, bool autoSend)
+        private void ReadParameters(BinaryReader reader, bool autoSend)
         {
-            if (m_AnimatorParameters == null) m_AnimatorParameters = m_Animator.parameters;
-            for (int i = 0; i < m_AnimatorParameters.Length; i++)
+            if (animatorParameters == null)
+                animatorParameters = animator.parameters;
+
+            for (int i = 0; i < animatorParameters.Length; i++)
             {
                 if (autoSend && !GetParameterAutoSend(i))
                     continue;
 
-                AnimatorControllerParameter par = m_AnimatorParameters[i];
+                AnimatorControllerParameter par = animatorParameters[i];
                 if (par.type == AnimatorControllerParameterType.Int)
                 {
                     int newValue = (int)reader.ReadUInt32();
-                    m_Animator.SetInteger(par.nameHash, newValue);
+                    animator.SetInteger(par.nameHash, newValue);
 
                     SetRecvTrackingParam(par.name + ":" + newValue, i);
                 }
 
                 if (par.type == AnimatorControllerParameterType.Float)
                 {
                     float newFloatValue = reader.ReadSingle();
-                    m_Animator.SetFloat(par.nameHash, newFloatValue);
+                    animator.SetFloat(par.nameHash, newFloatValue);
 
                     SetRecvTrackingParam(par.name + ":" + newFloatValue, i);
                 }
 
                 if (par.type == AnimatorControllerParameterType.Bool)
                 {
                     bool newBoolValue = reader.ReadBoolean();
-                    m_Animator.SetBool(par.nameHash, newBoolValue);
+                    animator.SetBool(par.nameHash, newBoolValue);
 
                     SetRecvTrackingParam(par.name + ":" + newBoolValue, i);
                 }

Original file line number	Diff line number	Diff line change
`@@ -1,27 +1,36 @@`
`1`		`-using System;`
`2`		`-using System.IO;`
	`1`	`+using System.IO;`
`3`	`2`	`using UnityEngine;`
`4`	`3`
`5`	`4`	`namespace MLAPI`
`6`	`5`	`{`
`7`		`- [DisallowMultipleComponent]`
`8`		`- [RequireComponent(typeof(Animator))]`
`9`	`6`	`public class NetworkedAnimator : NetworkedBehaviour`
`10`	`7`	`{`
`11`		`- // configuration`
`12`		`- [SerializeField] Animator m_Animator;`
`13`		`- [SerializeField] uint m_ParameterSendBits;`
`14`		`- [SerializeField] float m_SendRate = 0.1f;`
	`8`	`+ [SerializeField]`
	`9`	`+ private Animator _animator;`
	`10`	`+ [SerializeField]`
	`11`	`+ private uint parameterSendBits;`
	`12`	`+ [SerializeField]`
	`13`	`+ private float sendRate = 0.1f;`
	`14`	`+ private AnimatorControllerParameter[] animatorParameters;`
	`15`	`+`
	`16`	`+ private int animationHash;`
	`17`	`+ private int transitionHash;`
	`18`	`+ private float sendTimer;`
	`19`	`+`
	`20`	`+ // tracking - these should probably move to a Preview component. -- Comment from HLAPI. Needs clarification`
	`21`	`+ public string param0;`
	`22`	`+ public string param1;`
	`23`	`+ public string param2;`
	`24`	`+ public string param3;`
	`25`	`+ public string param4;`
	`26`	`+ public string param5;`
`15`	`27`
`16`		`- AnimatorControllerParameter[] m_AnimatorParameters;`
`17`		`-`
`18`		`- // properties`
`19`	`28`	`public Animator animator`
`20`	`29`	`{`
`21`		`- get { return m_Animator; }`
	`30`	`+ get { return _animator; }`
`22`	`31`	`set`
`23`	`32`	`{`
`24`		`- m_Animator = value;`
	`33`	`+ _animator = value;`
`25`	`34`	`ResetParameterOptions();`
`26`	`35`	`}`
`27`	`36`	`}`
`@@ -30,32 +39,20 @@ public void SetParameterAutoSend(int index, bool value)`
`30`	`39`	`{`
`31`	`40`	`if (value)`
`32`	`41`	`{`
`33`		`- m_ParameterSendBits \|= (uint)(1 << index);`
	`42`	`+ parameterSendBits \|= (uint)(1 << index);`
`34`	`43`	`}`
`35`	`44`	`else`
`36`	`45`	`{`
`37`		`- m_ParameterSendBits &= (uint)(~(1 << index));`
	`46`	`+ parameterSendBits &= (uint)(~(1 << index));`
`38`	`47`	`}`
`39`	`48`	`}`
`40`	`49`
`41`	`50`	`public bool GetParameterAutoSend(int index)`
`42`	`51`	`{`
`43`		`- return (m_ParameterSendBits & (uint)(1 << index)) != 0;`
	`52`	`+ return (parameterSendBits & (uint)(1 << index)) != 0;`
`44`	`53`	`}`
`45`	`54`
`46`		`- int m_AnimationHash;`
`47`		`- int m_TransitionHash;`
`48`		`- float m_SendTimer;`
`49`		`-`
`50`		`- // tracking - these should probably move to a Preview component.`
`51`		`- public string param0;`
`52`		`- public string param1;`
`53`		`- public string param2;`
`54`		`- public string param3;`
`55`		`- public string param4;`
`56`		`- public string param5;`
`57`		`-`
`58`		`- bool sendMessagesAllowed`
	`55`	`+ private bool sendMessagesAllowed`
`59`	`56`	`{`
`60`	`57`	`get`
`61`	`58`	`{`
`@@ -73,23 +70,22 @@ public override void NetworkStart()`
`73`	`70`	`public void ResetParameterOptions()`
`74`	`71`	`{`
`75`	`72`	`Debug.Log("ResetParameterOptions");`
`76`		`- m_ParameterSendBits = 0;`
`77`		`- m_AnimatorParameters = null;`
	`73`	`+ parameterSendBits = 0;`
	`74`	`+ animatorParameters = null;`
`78`	`75`	`}`
`79`	`76`
`80`		`- void FixedUpdate()`
	`77`	`+ private void FixedUpdate()`
`81`	`78`	`{`
`82`	`79`	`if (!sendMessagesAllowed)`
`83`	`80`	`return;`
`84`	`81`
`85`	`82`	`CheckSendRate();`
`86`	`83`
`87`		`- int stateHash;`
`88`		`- float normalizedTime;`
`89`		`- if (!CheckAnimStateChanged(out stateHash, out normalizedTime))`
	`84`	`+ if (!CheckAnimStateChanged(out int stateHash, out float normalizedTime))`
`90`	`85`	`{`
`91`	`86`	`return;`
`92`	`87`	`}`
	`88`	`+`
`93`	`89`	`using(MemoryStream stream = new MemoryStream())`
`94`	`90`	`{`
`95`	`91`	`using (BinaryWriter writer = new BinaryWriter(stream))`
`@@ -109,46 +105,46 @@ void FixedUpdate()`
`109`	`105`	`}`
`110`	`106`	`}`
`111`	`107`
`112`		`- bool CheckAnimStateChanged(out int stateHash, out float normalizedTime)`
	`108`	`+ private bool CheckAnimStateChanged(out int stateHash, out float normalizedTime)`
`113`	`109`	`{`
`114`	`110`	`stateHash = 0;`
`115`	`111`	`normalizedTime = 0;`
`116`	`112`
`117`		`- if (m_Animator.IsInTransition(0))`
	`113`	`+ if (animator.IsInTransition(0))`
`118`	`114`	`{`
`119`		`- AnimatorTransitionInfo tt = m_Animator.GetAnimatorTransitionInfo(0);`
`120`		`- if (tt.fullPathHash != m_TransitionHash)`
	`115`	`+ AnimatorTransitionInfo animationTransitionInfo = animator.GetAnimatorTransitionInfo(0);`
	`116`	`+ if (animationTransitionInfo.fullPathHash != transitionHash)`
`121`	`117`	`{`
`122`	`118`	`// first time in this transition`
`123`		`- m_TransitionHash = tt.fullPathHash;`
`124`		`- m_AnimationHash = 0;`
	`119`	`+ transitionHash = animationTransitionInfo.fullPathHash;`
	`120`	`+ animationHash = 0;`
`125`	`121`	`return true;`
`126`	`122`	`}`
`127`	`123`	`return false;`
`128`	`124`	`}`
`129`	`125`
`130`		`- AnimatorStateInfo st = m_Animator.GetCurrentAnimatorStateInfo(0);`
`131`		`- if (st.fullPathHash != m_AnimationHash)`
	`126`	`+ AnimatorStateInfo animationSateInfo = animator.GetCurrentAnimatorStateInfo(0);`
	`127`	`+ if (animationSateInfo.fullPathHash != animationHash)`
`132`	`128`	`{`
`133`	`129`	`// first time in this animation state`
`134`		`- if (m_AnimationHash != 0)`
	`130`	`+ if (animationHash != 0)`
`135`	`131`	`{`
`136`	`132`	`// came from another animation directly - from Play()`
`137`		`- stateHash = st.fullPathHash;`
`138`		`- normalizedTime = st.normalizedTime;`
	`133`	`+ stateHash = animationSateInfo.fullPathHash;`
	`134`	`+ normalizedTime = animationSateInfo.normalizedTime;`
`139`	`135`	`}`
`140`		`- m_TransitionHash = 0;`
`141`		`- m_AnimationHash = st.fullPathHash;`
	`136`	`+ transitionHash = 0;`
	`137`	`+ animationHash = animationSateInfo.fullPathHash;`
`142`	`138`	`return true;`
`143`	`139`	`}`
`144`	`140`	`return false;`
`145`	`141`	`}`
`146`	`142`
`147`		`- void CheckSendRate()`
	`143`	`+ private void CheckSendRate()`
`148`	`144`	`{`
`149`		`- if (sendMessagesAllowed && m_SendRate != 0 && m_SendTimer < Time.time)`
	`145`	`+ if (sendMessagesAllowed && sendRate != 0 && sendTimer < Time.time)`
`150`	`146`	`{`
`151`		`- m_SendTimer = Time.time + m_SendRate;`
	`147`	`+ sendTimer = Time.time + sendRate;`
`152`	`148`
`153`	`149`	`using(MemoryStream stream = new MemoryStream())`
`154`	`150`	`{`
`@@ -168,7 +164,7 @@ void CheckSendRate()`
`168`	`164`	`}`
`169`	`165`	`}`
`170`	`166`
`171`		`- void SetSendTrackingParam(string p, int i)`
	`167`	`+ private void SetSendTrackingParam(string p, int i)`
`172`	`168`	`{`
`173`	`169`	`p = "Sent Param: " + p;`
`174`	`170`	`if (i == 0) param0 = p;`
`@@ -179,7 +175,7 @@ void SetSendTrackingParam(string p, int i)`
`179`	`175`	`if (i == 5) param5 = p;`
`180`	`176`	`}`
`181`	`177`
`182`		`- void SetRecvTrackingParam(string p, int i)`
	`178`	`+ private void SetRecvTrackingParam(string p, int i)`
`183`	`179`	`{`
`184`	`180`	`p = "Recv Param: " + p;`
`185`	`181`	`if (i == 0) param0 = p;`
`@@ -190,13 +186,12 @@ void SetRecvTrackingParam(string p, int i)`
`190`	`186`	`if (i == 5) param5 = p;`
`191`	`187`	`}`
`192`	`188`
`193`		`- internal void HandleAnimMsg(int clientId, byte[] data)`
	`189`	`+ private void HandleAnimMsg(int clientId, byte[] data)`
`194`	`190`	`{`
`195`	`191`	`// usually transitions will be triggered by parameters, if not, play anims directly.`
`196`	`192`	`// NOTE: this plays "animations", not transitions, so any transitions will be skipped.`
`197`	`193`	`// NOTE: there is no API to play a transition(?)`
`198`	`194`
`199`		`- //isServer AND the message is not from ourselves. This prevents a stack overflow. Infinite call to itself.`
`200`	`195`	`if(isServer)`
`201`	`196`	`{`
`202`	`197`	`SendToNonLocalClientsTarget("MLAPI_HandleAnimationMessage", "MLAPI_ANIMATION_UPDATE", data, true);`
`@@ -209,14 +204,14 @@ internal void HandleAnimMsg(int clientId, byte[] data)`
`209`	`204`	`float normalizedTime = reader.ReadSingle();`
`210`	`205`	`if(stateHash != 0)`
`211`	`206`	`{`
`212`		`- m_Animator.Play(stateHash, 0, normalizedTime);`
	`207`	`+ animator.Play(stateHash, 0, normalizedTime);`
`213`	`208`	`}`
`214`	`209`	`ReadParameters(reader, false);`
`215`	`210`	`}`
`216`	`211`	`}`
`217`	`212`	`}`
`218`	`213`
`219`		`- internal void HandleAnimParamsMsg(int clientId, byte[] data)`
	`214`	`+ private void HandleAnimParamsMsg(int clientId, byte[] data)`
`220`	`215`	`{`
`221`	`216`	`if (isServer)`
`222`	`217`	`{`
`@@ -231,7 +226,7 @@ internal void HandleAnimParamsMsg(int clientId, byte[] data)`
`231`	`226`	`}`
`232`	`227`	`}`
`233`	`228`
`234`		`- internal void HandleAnimTriggerMsg(int clientId, byte[] data)`
	`229`	`+ private void HandleAnimTriggerMsg(int clientId, byte[] data)`
`235`	`230`	`{`
`236`	`231`	`if (isServer)`
`237`	`232`	`{`
`@@ -241,72 +236,76 @@ internal void HandleAnimTriggerMsg(int clientId, byte[] data)`
`241`	`236`	`{`
`242`	`237`	`using(BinaryReader reader = new BinaryReader(stream))`
`243`	`238`	`{`
`244`		`- m_Animator.SetTrigger(reader.ReadInt32());`
	`239`	`+ animator.SetTrigger(reader.ReadInt32());`
`245`	`240`	`}`
`246`	`241`	`}`
`247`	`242`	`}`
`248`	`243`
`249`		`- void WriteParameters(BinaryWriter writer, bool autoSend)`
	`244`	`+ private void WriteParameters(BinaryWriter writer, bool autoSend)`
`250`	`245`	`{`
`251`		`- if (m_AnimatorParameters == null) m_AnimatorParameters = m_Animator.parameters;`
`252`		`- for (int i = 0; i < m_AnimatorParameters.Length; i++)`
	`246`	`+ if (animatorParameters == null)`
	`247`	`+ animatorParameters = animator.parameters;`
	`248`	`+`
	`249`	`+ for (int i = 0; i < animatorParameters.Length; i++)`
`253`	`250`	`{`
`254`	`251`	`if (autoSend && !GetParameterAutoSend(i))`
`255`	`252`	`continue;`
`256`	`253`
`257`		`- AnimatorControllerParameter par = m_AnimatorParameters[i];`
	`254`	`+ AnimatorControllerParameter par = animatorParameters[i];`
`258`	`255`	`if (par.type == AnimatorControllerParameterType.Int)`
`259`	`256`	`{`
`260`		`- writer.Write((uint)m_Animator.GetInteger(par.nameHash));`
	`257`	`+ writer.Write((uint)animator.GetInteger(par.nameHash));`
`261`	`258`
`262`		`- SetSendTrackingParam(par.name + ":" + m_Animator.GetInteger(par.nameHash), i);`
	`259`	`+ SetSendTrackingParam(par.name + ":" + animator.GetInteger(par.nameHash), i);`
`263`	`260`	`}`
`264`	`261`
`265`	`262`	`if (par.type == AnimatorControllerParameterType.Float)`
`266`	`263`	`{`
`267`		`- writer.Write(m_Animator.GetFloat(par.nameHash));`
	`264`	`+ writer.Write(animator.GetFloat(par.nameHash));`
`268`	`265`
`269`		`- SetSendTrackingParam(par.name + ":" + m_Animator.GetFloat(par.nameHash), i);`
	`266`	`+ SetSendTrackingParam(par.name + ":" + animator.GetFloat(par.nameHash), i);`
`270`	`267`	`}`
`271`	`268`
`272`	`269`	`if (par.type == AnimatorControllerParameterType.Bool)`
`273`	`270`	`{`
`274`		`- writer.Write(m_Animator.GetBool(par.nameHash));`
	`271`	`+ writer.Write(animator.GetBool(par.nameHash));`
`275`	`272`
`276`		`- SetSendTrackingParam(par.name + ":" + m_Animator.GetBool(par.nameHash), i);`
	`273`	`+ SetSendTrackingParam(par.name + ":" + animator.GetBool(par.nameHash), i);`
`277`	`274`	`}`
`278`	`275`	`}`
`279`	`276`	`}`
`280`	`277`
`281`		`- void ReadParameters(BinaryReader reader, bool autoSend)`
	`278`	`+ private void ReadParameters(BinaryReader reader, bool autoSend)`
`282`	`279`	`{`
`283`		`- if (m_AnimatorParameters == null) m_AnimatorParameters = m_Animator.parameters;`
`284`		`- for (int i = 0; i < m_AnimatorParameters.Length; i++)`
	`280`	`+ if (animatorParameters == null)`
	`281`	`+ animatorParameters = animator.parameters;`
	`282`	`+`
	`283`	`+ for (int i = 0; i < animatorParameters.Length; i++)`
`285`	`284`	`{`
`286`	`285`	`if (autoSend && !GetParameterAutoSend(i))`
`287`	`286`	`continue;`
`288`	`287`
`289`		`- AnimatorControllerParameter par = m_AnimatorParameters[i];`
	`288`	`+ AnimatorControllerParameter par = animatorParameters[i];`
`290`	`289`	`if (par.type == AnimatorControllerParameterType.Int)`
`291`	`290`	`{`
`292`	`291`	`int newValue = (int)reader.ReadUInt32();`
`293`		`- m_Animator.SetInteger(par.nameHash, newValue);`
	`292`	`+ animator.SetInteger(par.nameHash, newValue);`
`294`	`293`
`295`	`294`	`SetRecvTrackingParam(par.name + ":" + newValue, i);`
`296`	`295`	`}`
`297`	`296`
`298`	`297`	`if (par.type == AnimatorControllerParameterType.Float)`
`299`	`298`	`{`
`300`	`299`	`float newFloatValue = reader.ReadSingle();`
`301`		`- m_Animator.SetFloat(par.nameHash, newFloatValue);`
	`300`	`+ animator.SetFloat(par.nameHash, newFloatValue);`
`302`	`301`
`303`	`302`	`SetRecvTrackingParam(par.name + ":" + newFloatValue, i);`
`304`	`303`	`}`
`305`	`304`
`306`	`305`	`if (par.type == AnimatorControllerParameterType.Bool)`
`307`	`306`	`{`
`308`	`307`	`bool newBoolValue = reader.ReadBoolean();`
`309`		`- m_Animator.SetBool(par.nameHash, newBoolValue);`
	`308`	`+ animator.SetBool(par.nameHash, newBoolValue);`
`310`	`309`
`311`	`310`	`SetRecvTrackingParam(par.name + ":" + newBoolValue, i);`
`312`	`311`	`}`