protected override void OnGUI_Internal(Rect rect, SerializedProperty property, GUIContent label) { AnimatorParamAttribute animatorParamAttribute = PropertyUtility.GetAttribute <AnimatorParamAttribute>(property); AnimatorController animatorController = GetAnimatorController(property, animatorParamAttribute.AnimatorName); if (animatorController == null) { DrawDefaultPropertyAndHelpBox(rect, property, InvalidAnimatorControllerWarningMessage, MessageType.Warning); return; } int parametersCount = animatorController.parameters.Length; List <AnimatorControllerParameter> animatorParameters = new List <AnimatorControllerParameter>(parametersCount); for (int i = 0; i < parametersCount; i++) { AnimatorControllerParameter parameter = animatorController.parameters[i]; if (animatorParamAttribute.AnimatorParamType == null || parameter.type == animatorParamAttribute.AnimatorParamType) { animatorParameters.Add(parameter); } } switch (property.propertyType) { case SerializedPropertyType.Integer: DrawPropertyForInt(rect, property, label, animatorParameters); break; case SerializedPropertyType.String: DrawPropertyForString(rect, property, label, animatorParameters); break; default: DrawDefaultPropertyAndHelpBox(rect, property, string.Format(InvalidTypeWarningMessage, property.name), MessageType.Warning); break; } }
public AnimatorParameterSaveData(Animator animator, AnimatorControllerParameter parameter) { id = parameter.nameHash; parameterType = parameter.type; switch (parameterType) { case AnimatorControllerParameterType.Bool: boolValue = animator.GetBool(id); break; case AnimatorControllerParameterType.Float: floatValue = animator.GetFloat(id); break; case AnimatorControllerParameterType.Int: intValuie = animator.GetInteger(id); break; case AnimatorControllerParameterType.Trigger: break; } }
void ReadParameters(NetworkReader reader) { // need to read values from NetworkReader even if animator is disabled ulong dirtyBits = reader.ReadPackedUInt64(); for (int i = 0; i < parameters.Length; i++) { if ((dirtyBits & (1ul << i)) == 0) { continue; } AnimatorControllerParameter par = parameters[i]; switch (par.type) { case AnimatorControllerParameterType.Int: { int newIntValue = reader.ReadPackedInt32(); SetInteger(par, newIntValue); break; } case AnimatorControllerParameterType.Float: { float newFloatValue = reader.ReadSingle(); SetFloat(par, newFloatValue); break; } case AnimatorControllerParameterType.Bool: { bool newBoolValue = reader.ReadBoolean(); SetBool(par, newBoolValue); break; } } } }
public static void ResetParameters(this Animator animator) { AnimatorControllerParameter[] parameters = animator.parameters; for (int i = 0; i < parameters.Length; i++) { AnimatorControllerParameter parameter = parameters[i]; switch (parameter.type) { case AnimatorControllerParameterType.Int: animator.SetInteger(parameter.name, parameter.defaultInt); break; case AnimatorControllerParameterType.Float: animator.SetFloat(parameter.name, parameter.defaultFloat); break; case AnimatorControllerParameterType.Bool: animator.SetBool(parameter.name, parameter.defaultBool); break; } } }
void ReadParameters(NetworkReader reader) { ulong dirtyBits = reader.ReadUInt64(); for (int i = 0; i < parameters.Length; i++) { if ((dirtyBits & (1ul << i)) == 0) { continue; } AnimatorControllerParameter par = parameters[i]; if (par.type == AnimatorControllerParameterType.Int) { int newIntValue = reader.ReadInt32(); _animator.SetInteger(par.nameHash, newIntValue); } else if (par.type == AnimatorControllerParameterType.Float) { float newFloatValue = reader.ReadSingle(); if (_smoothFloats) { float currentValue = _animator.GetFloat(par.nameHash); float past = base.syncInterval + _interpolationFallbehind; float rate = Mathf.Abs(currentValue - newFloatValue) / past; _floatTargets[par.nameHash] = new LerpingFloat(rate, newFloatValue); } else { _animator.SetFloat(par.nameHash, newFloatValue); } } else if (par.type == AnimatorControllerParameterType.Bool) { bool newBoolValue = reader.ReadBoolean(); _animator.SetBool(par.nameHash, newBoolValue); } } }
void ReadParameters(NetworkReader reader, bool autoSend) { // store the animator parameters in a variable - the "Animator.parameters" getter allocates // a new parameter array every time it is accessed so we should avoid doing it in a loop AnimatorControllerParameter[] parameters = m_Animator.parameters; for (int i = 0; i < parameters.Length; i++) { if (autoSend && !GetParameterAutoSend(i)) { continue; } AnimatorControllerParameter par = parameters[i]; if (par.type == AnimatorControllerParameterType.Int) { int newValue = (int)reader.ReadPackedUInt32(); m_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); SetRecvTrackingParam(par.name + ":" + newFloatValue, i); } if (par.type == AnimatorControllerParameterType.Bool) { bool newBoolValue = reader.ReadBoolean(); m_Animator.SetBool(par.nameHash, newBoolValue); SetRecvTrackingParam(par.name + ":" + newBoolValue, i); } } }
/************************************************* * * Animatior Enhancement * *************************************************/ /// <summary> /// 复制 Animator ,注意 trigger 是不能复制的(一般而言也不用复制) /// </summary> public static void CopyTo(this Animator from, Animator to) { if (from == to || from == null || to == null) { return; } // Copy Parameter AnimatorControllerParameter [] parameters = from.parameters; for (int i = 0; i < parameters.Length; i++) { AnimatorControllerParameter param = parameters[i]; switch (param.type) { case AnimatorControllerParameterType.Bool: to.SetBool(param.nameHash, from.GetBool(param.nameHash)); break; case AnimatorControllerParameterType.Float: to.SetFloat(param.nameHash, from.GetFloat(param.nameHash)); break; case AnimatorControllerParameterType.Int: to.SetInteger(param.nameHash, from.GetInteger(param.nameHash)); break; } } // Copy Current State for (int i = 0; i < from.layerCount; i++) { AnimatorStateInfo info = from.GetCurrentAnimatorStateInfo(i); to.Play(info.fullPathHash, i, info.normalizedTime); } // Copy Transform from.transform.CopyTo(to.transform, true); }
public static void Awake(this AnimatorComponent self) { Animator animator = self.Parent.GetComponent <GameObjectComponent>().GameObject.GetComponent(typeof(Animator)) as Animator; if (animator == null) { return; } if (animator.runtimeAnimatorController == null) { return; } if (animator.runtimeAnimatorController.animationClips == null) { return; } self.Animator = animator; int count = animator.GetanimationClipsLength(); Array animationClipArray = animator.runtimeAnimatorController.animationClips; // animator.runtimeAnimatorController.animationClips; for (int i = 0; i < count; ++i) { AnimationClip animationClip = (AnimationClip)animationClipArray.GetValue(i); self.animationClips[animationClip.name] = animationClip; } count = animator.GetAnimatorControllerParameterLength(); Array parametersArray = animator.parameters; for (int i = 0; i < count; ++i) { AnimatorControllerParameter animatorControllerParameter = (AnimatorControllerParameter)parametersArray.GetValue(i); self.Parameter.Add(animatorControllerParameter.name); } }
/// <summary> /// Load the previous state of an animation parameter /// </summary> /// <param name="param">The animation parameter to load.</param> private void RetrieveParameter(AnimatorControllerParameter param) { string key = guid.ToString() + "_" + param.name; string folder = StaticFolders.ANIMATION; // Set the value based on the parameter type. switch (param.type) { case AnimatorControllerParameterType.Int: { key += Keys.ANIM_INT; if (VSave.Get(folder, key, out int value)) { anim.SetInteger(param.name, value); } break; } case AnimatorControllerParameterType.Bool: { key += Keys.ANIM_BOOL; if (VSave.Get(folder, key, out bool value)) { anim.SetBool(param.name, value); } break; } case AnimatorControllerParameterType.Float: { key += Keys.ANIM_FLOAT; if (VSave.Get(folder, key, out float value)) { anim.SetFloat(param.name, value); } break; } default: return; // Triggers fire one off. They don't need to be stored. } }
public void DoTransitionPreview() { if (m_Controller == null) { return; } if (Event.current.type == EventType.Repaint) { m_AvatarPreview.timeControl.Update(); } DoTimeline(); // Draw the blend values AnimatorControllerParameter[] parameters = m_Controller.parameters; if (parameters.Length > 0) { m_ShowBlendValue = EditorGUILayout.Foldout(m_ShowBlendValue, "BlendTree Parameters", true); if (m_ShowBlendValue) { for (int i = 0; i < parameters.Length; i++) { AnimatorControllerParameter parameter = m_Controller.parameters[i]; float value = m_ParameterInfoList[i].m_Value; float newValue = EditorGUILayout.Slider(parameter.name, value, m_ParameterMinMax[i][0], m_ParameterMinMax[i][1]); if (newValue != value) { m_ParameterInfoList[i].m_Value = newValue; mustResample = true; m_MustSampleMotions = true; } } } } }
/// <summary> /// Will set the Animation with the supplied parameter /// </summary> /// <param name="animation">The Animation to set</param> /// <param name="animator">The animator to get the Animations</param> /// <param name="parameter">The value for the Animation</param> public static void setAnimationTypeAndValue(Animation animation, Animator animator, object value) { if (value == null) { return; } //Grab what Type of parameter AnimatorControllerParameter param = getAnimatorControllerParameter(animation, animator); //If param doesn't exist, just get out if (param == null) { return; } switch (param.type) { case AnimatorControllerParameterType.Bool: animator.SetBool(animation.ToString(), (bool)value); break; case AnimatorControllerParameterType.Float: animator.SetFloat(animation.ToString(), (float)value); break; case AnimatorControllerParameterType.Int: animator.SetInteger(animation.ToString(), (int)value); break; case AnimatorControllerParameterType.Trigger: animator.SetTrigger(animation.ToString()); break; default: break; } }
/// <summary> /// Idle状態にする。 /// </summary> public void PlayIdle() { int count = CacheAnimator.parameters.Length; for (int i = 0; i < count; i++) { AnimatorControllerParameter param = CacheAnimator.parameters[i]; if (param.type == AnimatorControllerParameterType.Bool) { CacheAnimator.SetBool(param.name, param.defaultBool); } else if (param.type == AnimatorControllerParameterType.Int) { CacheAnimator.SetInteger(param.name, param.defaultInt); } else if (param.type == AnimatorControllerParameterType.Float) { CacheAnimator.SetFloat(param.name, param.defaultFloat); } } //PlayMotion(); }
private List <AnimatorControllerParameter> GetAnimatorControllerParameter() { if (_combo == null) { Debug.LogError("Combo is null."); return(null); } if (_CharacterAnimatorNamingList == null) { Debug.LogError("CharacterAnimatorNamingList is null."); return(null); } List <AnimatorControllerParameter> AnimatorControllerParameters = new List <AnimatorControllerParameter>(); AnimatorControllerParameter _normalizedParam = ParameterCreator.CreateParameter(_CharacterAnimatorNamingList.NormalizedTimeParameterName, AnimatorControllerParameterType.Float); AnimatorControllerParameter _speedParam = ParameterCreator.CreateParameter(_CharacterAnimatorNamingList.SpeedParameterName, AnimatorControllerParameterType.Float); AnimatorControllerParameters.Add(_combo.AnimatorControllerParameter); AnimatorControllerParameters.Add(_normalizedParam); AnimatorControllerParameters.Add(_speedParam); return(AnimatorControllerParameters); }
public static bool AnimeParamFindSet( UnityEngine.Animator animator, Tuple <string, object>[] nameValues, AnimatorControllerParameter[] animParams) { bool flag = false; using (IEnumerator <\u003C\u003E__AnonType33 <AnimatorControllerParameterType, Tuple <string, object> > > enumerator = ((IEnumerable <Tuple <string, object> >)nameValues).Select <Tuple <string, object>, \u003C\u003E__AnonType33 <AnimatorControllerParameterType, Tuple <string, object> > >((Func <Tuple <string, object>, \u003C\u003E__AnonType33 <AnimatorControllerParameterType, Tuple <string, object> > >)(v => { AnimatorControllerParameter controllerParameter = ((IEnumerable <AnimatorControllerParameter>)animParams).FirstOrDefault <AnimatorControllerParameter>((Func <AnimatorControllerParameter, bool>)(p => p.get_name() == v.Item1)); // ISSUE: object of a compiler-generated type is created return(controllerParameter == null ? (\u003C\u003E__AnonType33 <AnimatorControllerParameterType, Tuple <string, object> >)null : new \u003C\u003E__AnonType33 <AnimatorControllerParameterType, Tuple <string, object> >(controllerParameter.get_type(), v)); })).GetEnumerator()) { while (((IEnumerator)enumerator).MoveNext()) { // ISSUE: variable of a compiler-generated type \u003C\u003E__AnonType33 <AnimatorControllerParameterType, Tuple <string, object> > current = enumerator.Current; flag |= Utils.Animator.AnimeParamSet(animator, current.value, current.type); } } return(flag); }
private void SetAnimatorParameterData(AnimatorControllerParameter param, object data) { AnimatorControllerParameterType type = param.type; if (type != AnimatorControllerParameterType.Int) { if (type != AnimatorControllerParameterType.Float) { if (type == AnimatorControllerParameterType.Bool) { this.m_Animator.SetBool(param.nameHash, (bool)data); } } else { this.m_Animator.SetFloat(param.nameHash, (float)data); } } else { this.m_Animator.SetInteger(param.nameHash, (int)data); } }
void Sync(NeutronReader streamReader) { using (streamReader) { object[] parameters = streamReader.ReadBytes(8192).DeserializeObject <object[]>(); for (int i = 0; i < parameters.Length; i++) { AnimatorControllerParameter parameter = GetAnimator.GetParameter(i); if (parameter.type == AnimatorControllerParameterType.Bool) { GetAnimator.SetBool(parameter.name, (bool)parameters[i]); } else if (parameter.type == AnimatorControllerParameterType.Float) { GetAnimator.SetFloat(parameter.name, (float)parameters[i]); } else if (parameter.type == AnimatorControllerParameterType.Int) { GetAnimator.SetInteger(parameter.name, (int)parameters[i]); } } } }
private void SetAnimatorParameterData(AnimatorControllerParameter param, object data) { switch (param.type) { case AnimatorControllerParameterType.Float: this.m_Animator.SetFloat(param.nameHash, (float)data); return; case (AnimatorControllerParameterType)2: break; case AnimatorControllerParameterType.Int: this.m_Animator.SetInteger(param.nameHash, (int)data); return; case AnimatorControllerParameterType.Bool: this.m_Animator.SetBool(param.nameHash, (bool)data); break; default: return; } }
private void Update() { if (isInterpolating) { // If we weren't previously interpolating, we need to cache the current float values from the animator before we start to interpolate. // Otherwise, there might be a noticeable jump as the parameters settle in. if (!wasInterpolating) { CacheFloatTargets(); } for (int i = 0; i < parameters.Length; i++) { AnimatorControllerParameter par = parameters[i]; if (par.type == AnimatorControllerParameterType.Float) { float newFloatValue = Mathf.Lerp(floatParametersTargets[i], animator.GetFloat(par.nameHash), interpolationFactor); animator.SetFloat(par.nameHash, newFloatValue); } } } wasInterpolating = isInterpolating; }
public static List <NetworkAnimatorParameter> GetAnimatorParams(Animator animator) { List <NetworkAnimatorParameter> dumppedparamList = new List <NetworkAnimatorParameter>(); AnimatorControllerParameter[] paramList = animator.parameters; //Logger.InfoFormat("Parameters Count; {0}", paramList.Length); for (int i = 0; i < paramList.Length; i++) { AnimatorControllerParameter param = paramList[i]; NetworkAnimatorParameter copyedParam = null; switch (param.type) { case AnimatorControllerParameterType.Bool: bool boolVal = animator.GetBool(param.nameHash); copyedParam = new NetworkAnimatorParameter(param.type, boolVal, param.nameHash); break; case AnimatorControllerParameterType.Float: float floatVal = animator.GetFloat(param.nameHash); copyedParam = new NetworkAnimatorParameter(param.type, floatVal, param.nameHash); break; case AnimatorControllerParameterType.Int: int intVal = animator.GetInteger(param.nameHash); copyedParam = new NetworkAnimatorParameter(param.type, intVal, param.nameHash); break; case AnimatorControllerParameterType.Trigger: throw new Exception("not supported"); } dumppedparamList.Add(copyedParam); } return(dumppedparamList); }
private void WriteParameters(BinaryWriter writer, bool autoSend) { if (animatorParameters == null) { animatorParameters = animator.parameters; } for (int i = 0; i < animatorParameters.Length; i++) { if (autoSend && !GetParameterAutoSend(i)) { continue; } AnimatorControllerParameter par = animatorParameters[i]; if (par.type == AnimatorControllerParameterType.Int) { writer.Write((uint)animator.GetInteger(par.nameHash)); SetSendTrackingParam(par.name + ":" + animator.GetInteger(par.nameHash), i); } if (par.type == AnimatorControllerParameterType.Float) { writer.Write(animator.GetFloat(par.nameHash)); SetSendTrackingParam(par.name + ":" + animator.GetFloat(par.nameHash), i); } if (par.type == AnimatorControllerParameterType.Bool) { writer.Write(animator.GetBool(par.nameHash)); SetSendTrackingParam(par.name + ":" + animator.GetBool(par.nameHash), i); } } }
void ReadParameters(NetworkReader reader) { ulong dirtyBits = reader.ReadPackedUInt64(); for (int i = 0; i < parameters.Length; i++) { if ((dirtyBits & (1ul << i)) == 0) { continue; } AnimatorControllerParameter par = parameters[i]; if (par.type == AnimatorControllerParameterType.Int) { int newIntValue = reader.ReadPackedInt32(); animator.SetInteger(par.nameHash, newIntValue); } else if (par.type == AnimatorControllerParameterType.Float) { float newFloatValue = reader.ReadSingle(); // If interpolating, set the target. Otherwise, set the value immediately. if (interpolateFloatParameters) { floatParametersTargets[i] = newFloatValue; } else { animator.SetFloat(par.nameHash, newFloatValue); } } else if (par.type == AnimatorControllerParameterType.Bool) { bool newBoolValue = reader.ReadBoolean(); animator.SetBool(par.nameHash, newBoolValue); } } }
public static bool HasParameter(this Animator i_Animator, int i_ParamNameHash) { if (i_Animator == null) { return(false); } for (int index = 0; index < i_Animator.parameterCount; ++index) { AnimatorControllerParameter parameter = i_Animator.GetParameter(index); if (parameter == null) { continue; } if (parameter.nameHash == i_ParamNameHash) { return(true); } } return(false); }
bool GetParameters(out object[] mParams) { object[] parametersToSend = new object[GetAnimator.parameterCount]; for (int i = 0; i < parametersToSend.Length; i++) { AnimatorControllerParameter parameter = GetAnimator.GetParameter(i); if (parameter.type == AnimatorControllerParameterType.Bool) { parametersToSend[i] = GetAnimator.GetBool(parameter.name); } else if (parameter.type == AnimatorControllerParameterType.Float) { parametersToSend[i] = GetAnimator.GetFloat(parameter.name); } else if (parameter.type == AnimatorControllerParameterType.Int) { parametersToSend[i] = GetAnimator.GetInteger(parameter.name); } } mParams = parametersToSend; //===========================// return(true); }
void WriteParameters(NetworkWriter writer, bool autoSend) { // store the animator parameters in a variable - the "Animator.parameters" getter allocates // a new parameter array every time it is accessed so we should avoid doing it in a loop AnimatorControllerParameter[] parameters = m_Animator.parameters; for (int i = 0; i < parameters.Length; i++) { if (autoSend && !GetParameterAutoSend(i)) { continue; } AnimatorControllerParameter par = parameters[i]; if (par.type == AnimatorControllerParameterType.Int) { writer.WritePackedUInt32((uint)m_Animator.GetInteger(par.nameHash)); SetSendTrackingParam(par.name + ":" + m_Animator.GetInteger(par.nameHash), i); } if (par.type == AnimatorControllerParameterType.Float) { writer.Write(m_Animator.GetFloat(par.nameHash)); SetSendTrackingParam(par.name + ":" + m_Animator.GetFloat(par.nameHash), i); } if (par.type == AnimatorControllerParameterType.Bool) { writer.Write(m_Animator.GetBool(par.nameHash)); SetSendTrackingParam(par.name + ":" + m_Animator.GetBool(par.nameHash), i); } } }
// ####################### save ######################### // public void Save() { //Save Data into Animator // parameters List <AnimatorControllerParameter> newParameters = new List <AnimatorControllerParameter>(); foreach (var input in inputs) { AnimatorControllerParameter controllerParameter = new AnimatorControllerParameter(); controllerParameter.name = input.parameterName; controllerParameter.type = input.type; controllerParameter.defaultBool = input.defaultBool; if (input.options.Count > input.defaultOptionIndex) { controllerParameter.defaultFloat = input.options[input.defaultOptionIndex].floatValue; controllerParameter.defaultInt = input.options[input.defaultOptionIndex].intValue; } newParameters.Add(controllerParameter); } // layers List <AnimatorControllerLayer> newLayers = new List <AnimatorControllerLayer>(); foreach (var layer in layers) { AnimatorControllerLayer controllerLayer = new AnimatorControllerLayer(); controllerLayer.name = layer.Name; controllerLayer.stateMachine = AddStateMachine(layer.stateMachine); controllerLayer.defaultWeight = 1; newLayers.Add(controllerLayer); } referenceAnimator.parameters = newParameters.ToArray(); referenceAnimator.layers = newLayers.ToArray(); }
public static void ResetParameter(Animator animator, AnimatorControllerParameter parameter) { switch (parameter.type) { case AnimatorControllerParameterType.Float: animator.SetFloat(parameter.name, parameter.defaultFloat); break; case AnimatorControllerParameterType.Int: animator.SetInteger(parameter.name, parameter.defaultInt); break; case AnimatorControllerParameterType.Bool: animator.SetBool(parameter.name, parameter.defaultBool); break; case AnimatorControllerParameterType.Trigger: animator.SetTrigger(parameter.name); break; default: break; } }
public static void SetAnimation(this Animator animator, AnimatorControllerParameter animationToSet, object parameter = null) { switch (animationToSet.type) { case AnimatorControllerParameterType.Int: animator.SetInteger(animationToSet.name, (int)parameter); break; case AnimatorControllerParameterType.Float: animator.SetFloat(animationToSet.name, (float)parameter); break; case AnimatorControllerParameterType.Bool: animator.SetBool(animationToSet.name, (bool)parameter); break; case AnimatorControllerParameterType.Trigger: animator.SetTrigger(animationToSet.name); break; default: throw new System.Exception("Cannot find animation type."); } }
private void DrawParameter(FireFxTreeDebuger d, Insp_TextInput insp) { if (d == null || insp == null || actionType == AnimatorActionType.Play) { return; } if (animTarget != AnimatorTarget.Host) { paramName = EditorGUILayout.TextField(insp.label, paramName); return; } EditorGUI.BeginChangeCheck(); string st = AnimatorGUI.ParameterField(d.hero, insp.label, paramName); if (EditorGUI.EndChangeCheck()) { insp.SetValueString(st); AnimatorControllerParameter p = EditAnimatorUtils.GetAnimParameter(d.hero, st); if (p != null) { paramType = p.type; } } }
protected void SetFlag(AnimatorControllerParameter param, bool flag) { switch (param.type) { case AnimatorControllerParameterType.Trigger: if (flag) { Animator.SetTrigger(param.name); } else { Animator.ResetTrigger(param.name); } break; case AnimatorControllerParameterType.Bool: Animator.SetBool(param.name, flag); break; case AnimatorControllerParameterType.Int: Animator.SetInteger(param.name, flag ? 1 : 0); break; } }
void ReadParameters(NetworkReader reader, bool autoSend) { m_AnimatorControllerParameters = m_Animator.parameters; for (int i = 0; i < m_AnimatorControllerParameters.Length; i++) { if (autoSend && !GetParameterAutoSend(i)) { continue; } m_AnimatorControllerParameter = m_AnimatorControllerParameters[i]; if (m_AnimatorControllerParameter.type == AnimatorControllerParameterType.Int) { int newValue = (int)reader.ReadPackedUInt32(); m_Animator.SetInteger(m_AnimatorControllerParameter.nameHash, newValue); SetRecvTrackingParam(m_AnimatorControllerParameter.name + ":" + newValue, i); } if (m_AnimatorControllerParameter.type == AnimatorControllerParameterType.Float) { float newFloatValue = reader.ReadSingle(); m_Animator.SetFloat(m_AnimatorControllerParameter.nameHash, newFloatValue); SetRecvTrackingParam(m_AnimatorControllerParameter.name + ":" + newFloatValue, i); } if (m_AnimatorControllerParameter.type == AnimatorControllerParameterType.Bool) { bool newBoolValue = reader.ReadBoolean(); m_Animator.SetBool(m_AnimatorControllerParameter.nameHash, newBoolValue); SetRecvTrackingParam(m_AnimatorControllerParameter.name + ":" + newBoolValue, i); } } }