/// <summary>
/// Registers a new animator parameter to the list
/// </summary>
/// <param name="parameterName">Parameter name.</param>
/// <param name="parameterType">Parameter type.</param>
protected virtual void RegisterAnimatorParameter(string parameterName, AnimatorControllerParameterType parameterType)
{
if (_animator.HasParameterOfType(parameterName, parameterType))
{
_character._animatorParameters.Add(parameterName);
}
}
private void DrawExtrap(AnimatorControllerParameterType type, ref ParameterExtrapolation e)
{
Rect r = EditorGUILayout.GetControlRect(GUILayout.MaxWidth(COL3));
ParameterExtrapolation newe;
if (type == AnimatorControllerParameterType.Bool || type == AnimatorControllerParameterType.Trigger)
{
newe = (ParameterExtrapolation)EditorGUI.EnumPopup(r, extGC, (ParameterMissingHold)e, new GUIStyle("MiniPopup")
{
margin = new RectOffset(0, 0, 0, 0)
});
}
else
{
newe = (ParameterExtrapolation)EditorGUI.EnumPopup(r, extGC, e, new GUIStyle("MiniPopup")
{
margin = new RectOffset(0, 0, 0, 0)
});
}
if (newe != e)
{
Undo.RecordObject(target, "Modify Sync Animator");
e = newe;
}
}
private void SelectFilterIndex()
{
_filterIndex = EditorPrefs.GetInt(KeyFilterIndex, 0);
switch (_currentFilter)
{
case Filter.StateEntered:
_filterIndex = ClampIndex(_filterIndex, _broadcasterStateNames.Length);
_filterIndex = EditorGUILayout.Popup("Filter", _filterIndex, _broadcasterStateNames);
break;
case Filter.ParameterName:
_filterIndex = ClampIndex(_filterIndex, _receiverParameterNames.Length);
_filterIndex = EditorGUILayout.Popup("Filter", _filterIndex, _receiverParameterNames);
break;
case Filter.ParameterType:
AnimatorControllerParameterType typeFilter = (AnimatorControllerParameterType)_filterIndex;
if (typeFilter != AnimatorControllerParameterType.Bool &&
typeFilter != AnimatorControllerParameterType.Int &&
typeFilter != AnimatorControllerParameterType.Float &&
typeFilter != AnimatorControllerParameterType.Trigger)
{
typeFilter = AnimatorControllerParameterType.Bool;
}
typeFilter = (AnimatorControllerParameterType)EditorGUILayout.EnumPopup("Filter", (System.Enum)typeFilter);
_filterIndex = (int)typeFilter;
break;
}
EditorPrefs.SetInt(KeyFilterIndex, _filterIndex);
}
private void DrawParameterSpecificField(VisualElement vis, AnimatorControllerParameterType animatorParameterType)
{
// -------------
PropertyField propertyField;
switch (animatorParameterType)
{
case AnimatorControllerParameterType.Bool:
propertyField = new PropertyField(_boolValue);
propertyField.tooltip = "...";
break;
case AnimatorControllerParameterType.Float:
propertyField = new PropertyField(_floatValue);
propertyField.tooltip = "...";
break;
case AnimatorControllerParameterType.Int:
propertyField = new PropertyField(_intValue);
propertyField.tooltip = "...";
break;
default:
return;
}
vis.Add(propertyField);
// -------------
}
public override void OnInspectorGUI()
{
this.serializedObject.Update();
EditorGUILayout.PropertyField(this.spAnimator, GUICONTENT_ANIMATOR);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(this.spParameterName, GUICONTENT_PARAM_NAME);
EditorGUILayout.PropertyField(this.spParameterType, GUICONTENT_PARAM_TYPE);
int paramTypeInt = this.spParameterType.intValue;
AnimatorControllerParameterType paramType = (AnimatorControllerParameterType)paramTypeInt;
switch (paramType)
{
case AnimatorControllerParameterType.Int:
EditorGUILayout.PropertyField(this.spParameterInteger, GUICONTENT_PARAM_INT);
break;
case AnimatorControllerParameterType.Float:
EditorGUILayout.PropertyField(this.spParameterFloat, GUICONTENT_PARAM_FLO);
break;
case AnimatorControllerParameterType.Bool:
EditorGUILayout.PropertyField(this.spParameterBool, GUICONTENT_PARAM_BOL);
break;
}
this.serializedObject.ApplyModifiedProperties();
}
private object GetAnimatorParameterData(AnimatorControllerParameter param)
{
object result = null;
AnimatorControllerParameterType type = param.type;
if (type != AnimatorControllerParameterType.Int)
{
if (type != AnimatorControllerParameterType.Float)
{
if (type == AnimatorControllerParameterType.Bool)
{
result = this.m_Animator.GetBool(param.nameHash);
}
}
else
{
result = this.m_Animator.GetFloat(param.nameHash);
}
}
else
{
result = this.m_Animator.GetInteger(param.nameHash);
}
return(result);
}
private void DrawButtonList(VisualElement vis, AnimatorControllerParameterType parameterType)
{
// -------------
if (_animator != null)
{
List <string> properties = _animator.parameters
.Where(x => x.type == parameterType)
.Select(x => x.name)
.ToList();
foreach (string element in properties)
{
Button btn = new Button(() =>
{
_animatorPropertyName.stringValue = element;
serializedObject.ApplyModifiedProperties();
})
{
text = element
};
btn.style.unityTextAlign = TextAnchor.MiddleLeft;
vis.Add(btn);
}
}
// -------------
}
public void FillParameterArray(RuntimeAnimatorController animator,AnimatorControllerParameterType type){
AnimatorController animatorController = animator as AnimatorController;
List<string> parameterNames = new List<string> ();
if (animatorController.parameterCount > 0) {
for (int i=0; i< animatorController.parameterCount; i++) {
if (animatorController.GetParameter (i).type == type) {
parameterNames.Add (animatorController.GetParameter (i).name);
}
}
switch(type){
case AnimatorControllerParameterType.Bool:
boolNames = parameterNames.ToArray ();
break;
case AnimatorControllerParameterType.Float:
floatNames = parameterNames.ToArray ();
break;
case AnimatorControllerParameterType.Int:
intNames = parameterNames.ToArray ();
break;
case AnimatorControllerParameterType.Trigger:
triggerNames = parameterNames.ToArray ();
break;
}
}
}
public void CreateAnimationUnit(string name, AnimatorControllerParameterType type, BoolVariable boolVariable = null, IntVariable intVariable = null, FloatVariable floatVariable = null, AtomEvent atomEvent = null)
{
AnimationUnit unit = ScriptableObject.CreateInstance <AnimationUnit>();
unit.name = name;
if (boolVariable != null)
{
unit.boolVariable = boolVariable;
BoolEvent boolEvent = ScriptableObject.CreateInstance <BoolEvent>();
boolVariable.Changed = boolEvent;
}
else if (intVariable != null)
{
unit.intVariable = intVariable;
IntEvent intEvent = ScriptableObject.CreateInstance <IntEvent>();
intVariable.Changed = intEvent;
}
else if (floatVariable != null)
{
unit.floatVariable = floatVariable;
FloatEvent floatEvent = ScriptableObject.CreateInstance <FloatEvent>();
floatVariable.Changed = floatEvent;
}
else if (atomEvent != null)
{
unit.atomEvent = atomEvent;
}
AddToAnimationUnits(unit);
SetUpAnimationUnit(unit);
}
private void CreateParamIfNotExists(string paramName, AnimatorControllerParameterType type)
{
if (_animatorController.parameters.FirstOrDefault(param => param.name == paramName) == null)
{
_animatorController.AddParameter(paramName, type);
}
}
void ModeAndThresholdPopUp(ref AnimatorConditionMode mode, ref float threshold, AnimatorControllerParameterType parameterType)
{
string[] displayedOptions = null;
int[] optionValues = null;
switch (parameterType)
{
case AnimatorControllerParameterType.Bool:
displayedOptions = new string[] { "true", "false" };
optionValues = new int[] { (int)AnimatorConditionMode.If, (int)AnimatorConditionMode.IfNot };
bool boolMode = EditorGUILayout.Toggle(mode == AnimatorConditionMode.If? true : false, GUILayout.MaxWidth(10f));
mode = boolMode ? AnimatorConditionMode.If : AnimatorConditionMode.IfNot;
break;
case AnimatorControllerParameterType.Int:
displayedOptions = new string[] { "<", "==", ">", "!=" };
optionValues = new int[] { (int)AnimatorConditionMode.Less, (int)AnimatorConditionMode.Equals, (int)AnimatorConditionMode.Greater, (int)AnimatorConditionMode.NotEqual };
int intMode = EditorGUILayout.IntPopup((int)mode, displayedOptions, optionValues);
int intThreshold = EditorGUILayout.IntField((int)threshold);
mode = (AnimatorConditionMode)intMode;
threshold = (int)intThreshold;
break;
case AnimatorControllerParameterType.Float:
displayedOptions = new string[] { "<", ">" };
optionValues = new int[] { (int)AnimatorConditionMode.Less, (int)AnimatorConditionMode.Greater };
int floatMode = EditorGUILayout.IntPopup((int)mode, displayedOptions, optionValues);
mode = (AnimatorConditionMode)floatMode;
threshold = EditorGUILayout.FloatField(threshold);
break;
case AnimatorControllerParameterType.Trigger:
break;
}
}
public static bool AnimeParamSet(
UnityEngine.Animator animator,
Tuple <string, object> nameValue,
AnimatorControllerParameterType type)
{
return(Utils.Animator.AnimeParamSet(animator, nameValue.Item1, nameValue.Item2, type));
}
public void FillParameterArray(RuntimeAnimatorController animator, AnimatorControllerParameterType type)
{
AnimatorController animatorController = animator as AnimatorController;
List <string> parameterNames = new List <string> ();
if (animatorController.parameterCount > 0)
{
for (int i = 0; i < animatorController.parameterCount; i++)
{
if (animatorController.GetParameter(i).type == type)
{
parameterNames.Add(animatorController.GetParameter(i).name);
}
}
switch (type)
{
case AnimatorControllerParameterType.Bool:
boolNames = parameterNames.ToArray();
break;
case AnimatorControllerParameterType.Float:
floatNames = parameterNames.ToArray();
break;
case AnimatorControllerParameterType.Int:
intNames = parameterNames.ToArray();
break;
case AnimatorControllerParameterType.Trigger:
triggerNames = parameterNames.ToArray();
break;
}
}
}
protected Vrc3Param(string name, AnimatorControllerParameterType type, float amplifier = 1f)
{
Name = name;
Type = type;
HashId = Animator.StringToHash(Name);
_amplifier = amplifier;
}
public void CopyFrom(AnimatorControllerParameter parameter)
{
_name = parameter.name;
_type = parameter.type;
_intValue = parameter.defaultInt;
_floatValue = parameter.defaultFloat;
_boolValue = parameter.defaultBool;
}
public AnimatorParameterInfo(Animator animator, AnimatorControllerParameter animatorControllerParameter)
{
this.animator = animator;
this.animatorControllerParameter = animatorControllerParameter;
this.name = this.animatorControllerParameter.name;
this.value = this.GetValue();
this.animatorControllerParameterType = animatorControllerParameter.type;
}
public void RegisterParameter(string name, out int parameter, AnimatorControllerParameterType type)
{
parameter = Animator.StringToHash(name);
if (HasParameterOfType(name, type))
{
_availableParameters.Add(parameter);
}
}
public void RewindTo(NetworkAnimatorParameter right)
{
ParamType = right.ParamType;
IntValue = right.IntValue;
FloatValue = right.FloatValue;
BoolValue = right.BoolValue;
NameHash = right.NameHash;
}
public void AddParameter(string name, AnimatorControllerParameterType type)
{
this.AddParameter(new AnimatorControllerParameter
{
name = this.MakeUniqueParameterName(name),
type = type
});
}
public void Bind(string parameter, Animator animator, AnimatorControllerParameterType type)
{
if (type == AnimatorControllerParameterType.Trigger)
{
_animator = animator;
_parameter = parameter;
}
}
public void CopyData(AnimatorControllerParameter des)
{
name = des.name;
nameHash = des.nameHash;
type = des.type;
defaultFloat = des.defaultFloat;
defaultInt = des.defaultInt;
defaultBool = des.defaultBool;
}
public static AnimatorControllerParameter CreateParameter(string name, AnimatorControllerParameterType type)
{
//Create Normalized Parameter
var param = new AnimatorControllerParameter();
param.name = name;
param.type = type;
return(param);
}
public void ReadFromFile(System.IO.BinaryReader pReader)
{
name = pReader.ReadString();
nameHash = pReader.ReadInt32();
type = (AnimatorControllerParameterType)pReader.ReadInt32();
defaultFloat = pReader.ReadSingle();
defaultInt = pReader.ReadInt32();
defaultBool = pReader.ReadBoolean();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="name">Name of the animation parameter to modify.</param>
/// <param name="parameterType">Type of the animation parameter to modify.</param>
/// <param name="defaultInt">If the animation parameter type is an int, value to set. Ignored otherwise.</param>
/// <param name="defaultFloat">If the animation parameter type is a float, value to set. Ignored otherwise.</param>
/// <param name="defaultBool">"If the animation parameter type is a bool, value to set. Ignored otherwise.</param>
public AnimatorParameter(string name, AnimatorControllerParameterType parameterType, int defaultInt = 0, float defaultFloat = 0f, bool defaultBool = false)
{
this.parameterType = parameterType;
this.defaultInt = defaultInt;
this.defaultFloat = defaultFloat;
this.defaultBool = defaultBool;
this.name = name;
nameStringHash = null;
}
public static bool AnimeParamSet(
UnityEngine.Animator animator,
string name,
object value,
AnimatorControllerParameterType type)
{
switch (type - 1)
{
case 0:
animator.SetFloat(name, (float)value);
break;
case 2:
animator.SetInteger(name, (int)value);
break;
case 3:
animator.SetBool(name, (bool)value);
break;
default:
if (type != 9)
{
return(false);
}
switch (value)
{
case null:
animator.ResetTrigger(name);
break;
case bool flag:
if (flag)
{
animator.SetTrigger(name);
break;
}
animator.ResetTrigger(name);
break;
case int num:
if (num != 0)
{
animator.SetTrigger(name);
break;
}
animator.ResetTrigger(name);
break;
default:
animator.SetTrigger(name);
break;
}
break;
}
return(true);
}
public void AddParameter(string name, AnimatorControllerParameterType type)
{
AnimatorControllerParameter newParameter = new AnimatorControllerParameter();
newParameter.name = MakeUniqueParameterName(name);
newParameter.type = type;
AddParameter(newParameter);
}
private static void DoAnimatorParameterPopup(GameObject go, AnimatorControllerParameterType parameterType, SkillString variable, object obj = null, FieldInfo field = null)
{
if (SkillEditorGUILayout.BrowseButton(go != null, string.Format(Strings.get_Tooltip_Browse_Animator_Parameters(), parameterType)))
{
StringEditor.editingVariable = variable;
StringEditor.editingObject = obj;
StringEditor.editingField = field;
StringEditor.DoAnimatorParameterMenu(go, parameterType);
}
}
public static AnimParam ReferenceTo(string name, AnimatorControllerParameterType type)
{
AnimParam p;
p.type = type;
p._name = name;
p._id = name == null ? 0 : Animator.StringToHash(name);
p._value = 0;
return(p);
}
public void MergeFromPatch(NetworkAnimatorParameter from)
{
ParamType = from._bitArray[0] ? from.ParamType : ParamType;
NameHash = from._bitArray[1] ? from.NameHash : NameHash;
BoolValue = from._bitArray[2] ? from.BoolValue : BoolValue;
FloatValue = from._bitArray[3] ? from.FloatValue : FloatValue;
IntValue = from._bitArray[4] ? from.IntValue : IntValue;
from._bitArray.ReleaseReference();
from._bitArray = null;
}
/// <summary>
/// Determines if an animator contains a certain parameter, based on a type and a name
/// </summary>
/// <returns><c>true</c> if has parameter of type the specified self name type; otherwise, <c>false</c>.</returns>
/// <param name="self">Self.</param>
/// <param name="name">Name.</param>
/// <param name="type">Type.</param>
public static bool HasParameterOfType(this Animator self, string name, AnimatorControllerParameterType type)
{
if (string.IsNullOrEmpty(name))
{
return(false);
}
var parameters = self.parameters;
return(parameters.Any(currParam => currParam.type == type && currParam.name == name));
}
private void TypeLabel(Rect r, AnimatorControllerParameterType ptype)
{
string typeinit =
ptype == AnimatorControllerParameterType.Bool ? "B" :
ptype == AnimatorControllerParameterType.Int ? "I" :
ptype == AnimatorControllerParameterType.Float ? "F" :
"T";
EditorGUI.LabelField(r, typeinit, (GUIStyle)"MiniLabel");
}
// Randomly set a trigger for the Animator on the GameObject
void Start()
{
anim = GetComponent<Animator> ();
acp = anim.parameters;
paramType = AnimatorControllerParameterType.Bool;
while (paramType != AnimatorControllerParameterType.Trigger){
randomIndex = Random.Range (0, acp.Length); //Random.Range is exclusive for the 2nd value
paramType = acp[randomIndex].type;
}
anim.SetTrigger (acp [randomIndex].name);
}
// Determines if an animator contains a certain parameter, based on a type and a name
public static bool HasParameterOfType (this Animator self, string name, AnimatorControllerParameterType type)
{
var parameters = self.parameters;
foreach (var currParam in parameters)
{
if (currParam.type == type && currParam.name == name)
{
return true;
}
}
return false;
}
private List<string> CollectParameters(AnimatorController controller, AnimatorControllerParameterType type)
{
List<string> list = new List<string>();
if (controller != null)
{
foreach (AnimatorControllerParameter parameter in controller.parameters)
{
if (parameter.type == type)
{
list.Add(parameter.name);
}
}
}
return list;
}
object GetParameterValue(Animator anim, AnimatorControllerParameterType type, int nameHash)
{
switch (type) {
case AnimatorControllerParameterType.Bool:
case AnimatorControllerParameterType.Trigger:
return anim.GetBool(nameHash);
case AnimatorControllerParameterType.Float:
return anim.GetFloat(nameHash);
case AnimatorControllerParameterType.Int:
return anim.GetInteger(nameHash);
default:
return null;
}
}
public void parseXml(XmlElement elem)
{
clear();
m_name = ExportUtil.getXmlAttrStr(elem.Attributes["name"]);
string typeStr = ExportUtil.getXmlAttrStr(elem.Attributes["type"]);
if(FLOAT == typeStr)
{
m_type = AnimatorControllerParameterType.Float;
}
else if (INT == typeStr)
{
m_type = AnimatorControllerParameterType.Int;
}
else if (BOOL == typeStr)
{
m_type = AnimatorControllerParameterType.Bool;
}
else if (TRIGGER == typeStr)
{
m_type = AnimatorControllerParameterType.Trigger;
}
}
private void OnParametrizedValueGUI(string name, SerializedProperty value, SerializedProperty valueParameter, SerializedProperty valueParameterActive, AnimatorControllerParameterType parameterType)
{
EditorGUILayout.PropertyField(value, new GUILayoutOption[0]);
if (this.controllerContext != null)
{
EditorGUI.indentLevel++;
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
List<string> list = this.CollectParameters(this.controllerContext, parameterType);
if ((list.Count == 0) && valueParameterActive.boolValue)
{
EditorGUILayout.HelpBox(string.Format("Must have at least one Parameter of type {0} in the AnimatorController", parameterType.ToString()), MessageType.Error);
}
else
{
if ((valueParameterActive.boolValue && (valueParameter.stringValue == "")) && (list.Count > 0))
{
valueParameter.stringValue = list[0];
}
using (new EditorGUI.DisabledScope(!valueParameterActive.boolValue))
{
EditorGUI.BeginChangeCheck();
string str = EditorGUILayout.TextFieldDropDown(new GUIContent("Multiplier", "Parameter used as multiplier for speed."), valueParameter.stringValue, list.ToArray());
if (EditorGUI.EndChangeCheck())
{
valueParameter.stringValue = str;
}
}
}
EditorGUI.indentLevel--;
GUILayoutOption[] options = new GUILayoutOption[] { GUILayout.MaxWidth(100f) };
valueParameterActive.boolValue = EditorGUILayout.ToggleLeft(new GUIContent("Parameter", "Use an AnimatorController's parameter to modulate this property at runtime."), valueParameterActive.boolValue, options);
EditorGUILayout.EndHorizontal();
}
}
private void OnParametrizedValueGUIOverride(string name, SerializedProperty value, SerializedProperty valueParameter, SerializedProperty valueParameterActive, AnimatorControllerParameterType parameterType)
{
if (this.controllerContext != null)
{
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
if (valueParameterActive.boolValue)
{
List<string> list = this.CollectParameters(this.controllerContext, parameterType);
if ((list.Count == 0) && valueParameterActive.boolValue)
{
EditorGUILayout.HelpBox(string.Format("Must have at least one Parameter of type {0} in the AnimatorController", parameterType.ToString()), MessageType.Error);
}
else
{
if ((valueParameterActive.boolValue && (valueParameter.stringValue == "")) && (list.Count > 0))
{
valueParameter.stringValue = list[0];
}
EditorGUI.BeginChangeCheck();
string str = EditorGUILayout.TextFieldDropDown(new GUIContent(name), valueParameter.stringValue, list.ToArray());
if (EditorGUI.EndChangeCheck())
{
valueParameter.stringValue = str;
}
}
}
else
{
EditorGUILayout.PropertyField(value, new GUILayoutOption[0]);
}
GUILayoutOption[] options = new GUILayoutOption[] { GUILayout.MaxWidth(100f) };
valueParameterActive.boolValue = EditorGUILayout.ToggleLeft(new GUIContent("Parameter", "Override this constant value with an AnimatorController's parameter to animate this property at runtime."), valueParameterActive.boolValue, options);
EditorGUILayout.EndHorizontal();
}
else
{
EditorGUILayout.PropertyField(value, new GUILayoutOption[0]);
}
}
/// <summary>
/// Determines whether this instance can add event name the specified animatorController index.
/// </summary>
/// <returns>
/// <c>true</c> if this instance can add event name the specified animatorController i; otherwise, <c>false</c>.
/// </returns>
/// <param name='animatorController'>
/// If set to <c>true</c> animator controller.
/// </param>
/// <param name='index'>
/// If set to <c>true</c> index.
/// </param>
bool CanAddEventName(AnimatorControllerParameterType animatorControllerParameterType)
{
return !(animatorParameterAttribute.parameterType != AnimatorParameterAttribute.ParameterType.None
&& (int)animatorControllerParameterType != (int)animatorParameterAttribute.parameterType);
}
public AnimatorControllerParameterAttribute(AnimatorControllerParameterType paramType)
{
ParamType = paramType;
}
private object GetParameterValue(int i, AnimatorControllerParameterType type, Animator animator) {
switch (type) {
case AnimatorControllerParameterType.Float:
return animator.GetFloat(i);
case AnimatorControllerParameterType.Int:
return animator.GetInteger(i);
case AnimatorControllerParameterType.Bool:
return animator.GetBool(i);
case AnimatorControllerParameterType.Trigger:
return animator.GetBool(i);
default:
return null;
}
}
public static string[] GetAnimatorParams(Animator _anim, AnimatorControllerParameterType _t)
{
List<string> paramList = new List<string> ();
paramList.Add("None");
for (int i = 0; i < _anim.parameterCount; i++) {
if (_anim.parameters [i].type == _t) {
paramList.Add (_anim.parameters [i].name);
}
}
return paramList.ToArray ();
}
