public void setTransition()
{
if (tran == null)
{
tran = targetController.layers[0].stateMachine.AddAnyStateTransition(state);
tran.duration = 0;
tran.hasFixedDuration = false;
tran.hasExitTime = false;
tran.canTransitionToSelf = false;
}
AnimatorCondition animatorCondition = new AnimatorCondition();
animatorCondition.mode = AnimatorConditionMode.Equals;
animatorCondition.parameter = "WeaponNumber";
animatorCondition.threshold = weaponNumber;
var cons = tran.conditions;
for (int i = 0; i < cons.Length; i++)
{
tran.RemoveCondition(cons[i]);
}
tran.AddCondition(AnimatorConditionMode.Equals, weaponNumber, "WeaponNumber");
tran.AddCondition(AnimatorConditionMode.Equals, comboCount, "ComboCount");
tran.AddCondition(AnimatorConditionMode.Equals, stateNumber, "State");
if (oneShot)
{
tran.canTransitionToSelf = true;
tran.AddCondition(AnimatorConditionMode.If, 0, "OneShot");
}
}
private static void ImportTransitions(AnimatorStateMachine stateMachine, ChildAnimatorState[] states)
{
var transitionEquality = new TransitionEqualityComparer();
foreach (var state in states)
{
foreach (var transition in state.state.transitions)
{
var fromState = FindStateByName(stateMachine, state.state.name);
var toState = FindStateByName(stateMachine, transition.destinationState.name);
AnimatorStateTransition newTransition = new AnimatorStateTransition();
newTransition.destinationState = toState;
var originalCondition = transition.conditions[0];
var conditionCopy = new AnimatorCondition();
conditionCopy.mode = originalCondition.mode;
conditionCopy.parameter = originalCondition.parameter;
conditionCopy.threshold = originalCondition.threshold;
newTransition.conditions = new AnimatorCondition[]
{
conditionCopy
};
if (!fromState.transitions.Contains(newTransition, transitionEquality))
{
fromState.AddTransition(newTransition);
}
}
}
}
private void ChangeGestureCondition(AnimatorController controller, int layerToModify, int newGesture)
{ // helper function: change gesture condition, in all transitions of 1 layer of controller
AnimatorStateMachine stateMachine = controller.layers[layerToModify].stateMachine;
ChildAnimatorState[] states = stateMachine.states;
List <AnimatorStateTransition> transitions = new List <AnimatorStateTransition>();
for (int i = 0; i < states.Length; i++)
{
transitions.AddRange(states[i].state.transitions);
}
AnimatorCondition[] conditions;
for (int i = 0; i < transitions.Count; i++)
{
conditions = transitions[i].conditions;
for (int j = 0; j < conditions.Length; j++)
{
if (conditions[j].parameter.Contains("Gesture"))
{
AnimatorCondition conditionToRemove = conditions[j];
transitions[i].RemoveCondition(conditionToRemove);
transitions[i].AddCondition(conditionToRemove.mode, newGesture, conditionToRemove.parameter);
break; // in my case, only one condition per transition includes GestureLeft / GestureRight
}
}
}
}
protected AnimatorTransitionBase(AssetLayout layout, AssetInfo assetInfo, BaseParameters parameters) :
base(layout)
{
AssetInfo = assetInfo;
ObjectHideFlags = HideFlags.HideInHierarchy;
List <AnimatorCondition> conditionList = new List <AnimatorCondition>(parameters.ConditionConstants.Count);
for (int i = 0; i < parameters.ConditionConstants.Count; i++)
{
ConditionConstant conditionConstant = parameters.ConditionConstants[i].Instance;
if (conditionConstant.ConditionMode != AnimatorConditionMode.ExitTime)
{
AnimatorCondition condition = new AnimatorCondition(conditionConstant, parameters.TOS);
conditionList.Add(condition);
}
}
Conditions = conditionList.ToArray();
AnimatorState state = parameters.GetDestinationState();
DstStateMachine = default;
DstState = state == null ? default : state.File.CreatePPtr(state);
Name = parameters.Name;
Solo = false;
Mute = false;
IsExit = parameters.IsExit;
}
AddCondition(
this AnimatorTransitionBase transition,
AnimatorCondition condition)
{
AnimatorCondition[] temp = transition.conditions;
ArrayUtility.Add(ref temp, condition);
transition.conditions = temp;
}
public static bool HasCondition(this AnimatorStateTransition obj, string parameter, AnimatorConditionMode mode, float threshold)
{
var condition = new AnimatorCondition {
parameter = parameter, mode = mode, threshold = threshold
};
return(obj.HasCondition(condition));
}
public ConditionDefinition(IAnimationDefinition parent, AnimatorCondition condition)
{
AnimatorCondition = condition;
Name = condition.parameter;
Parent = parent;
Mode = condition.mode;
Threshold = condition.threshold;
AddParameter(true, Name);
}
protected static AnimatorCondition getAnimatorCondition(string destinationStateName, float stateId)
{
AnimatorCondition condition = new AnimatorCondition();
condition.mode = AnimatorConditionMode.Equals;
condition.parameter = "State";
condition.threshold = stateId;
return(condition);
}
/// <param name="condition"></param>
/// <param name="lNum">レイヤー番号</param>
/// <param name="smNum">ステートマシン番号</param>
/// <param name="sNum">ステート番号</param>
/// <param name="tNum">トランジション番号</param>
/// <param name="cNum">コンディション番号</param>
/// <returns></returns>
public override bool OnCondition(AnimatorCondition condition, int lNum, int smNum, int sNum, int tNum, int cNum)
{
ConditionRecord conditionRecord = new ConditionRecord(
lNum,
smNum,
sNum,
tNum,
cNum,
condition);
AconDocument.conditions.Add(conditionRecord); return(true);
}
void AddBitKeySwitch(int index, AnimatorControllerLayer layer, AnimatorController controller)
{
string trueSwitchName = string.Format(BitKeySwitchName, "True", index);
string falseSwitchName = string.Format(BitKeySwitchName, "False", index);
AnimatorState falseState = layer.stateMachine.AddState(falseSwitchName);
falseState.motion = _clipsFalse[index];
falseState.speed = 1;
AnimatorCondition falseCondition = new AnimatorCondition
{
mode = AnimatorConditionMode.IfNot,
parameter = _avaCryptKeyNames[index],
threshold = 0
};
AnimatorStateTransition falseTransition = layer.stateMachine.AddAnyStateTransition(falseState);
falseTransition.canTransitionToSelf = false;
falseTransition.duration = 0;
falseTransition.conditions = new[] { falseCondition };
AnimatorState trueState = layer.stateMachine.AddState(trueSwitchName);
trueState.motion = _clipsTrue[index];
trueState.speed = 1;
AnimatorCondition trueCondition = new AnimatorCondition
{
mode = AnimatorConditionMode.If,
parameter = _avaCryptKeyNames[index],
};
AnimatorStateTransition trueTransition = layer.stateMachine.AddAnyStateTransition(trueState);
trueTransition.canTransitionToSelf = false;
trueTransition.duration = 0;
trueTransition.conditions = new[] { trueCondition };
AssetDatabase.SaveAssets();
}
private static AnimatorStateTransition[] getOptimizedAnimatorStateTransition(AnimatorStateTransition[] originalTransitions, GameObject prefab, Dictionary <UnityEngine.Object, UnityEngine.Object> originalToOptObjectReferences, string animationClipsFolder)
{
var optTransitions = new AnimatorStateTransition[originalTransitions.Length];
for (int i = 0; i < originalTransitions.Length; i++)
{
var originalTransition = originalTransitions[i];
var newTransition = new AnimatorStateTransition();
newTransition.canTransitionToSelf = originalTransition.canTransitionToSelf;
var optConditions = new AnimatorCondition[originalTransition.conditions.Length];
for (int j = 0; j < originalTransition.conditions.Length; j++)
{
var newCondition = new AnimatorCondition();
var originalCondition = originalTransition.conditions[j];
newCondition.mode = originalCondition.mode;
newCondition.parameter = originalCondition.parameter;
newCondition.threshold = originalCondition.threshold;
optConditions[j] = newCondition;
}
newTransition.conditions = optConditions;
newTransition.destinationState = getOptReference(originalTransition.destinationState, prefab, originalToOptObjectReferences, animationClipsFolder);
newTransition.destinationStateMachine = getOptReference(originalTransition.destinationStateMachine, prefab, originalToOptObjectReferences, animationClipsFolder);
newTransition.exitTime = originalTransition.exitTime;
newTransition.hasExitTime = originalTransition.hasExitTime;
newTransition.hasFixedDuration = originalTransition.hasFixedDuration;
newTransition.hideFlags = originalTransition.hideFlags;
newTransition.interruptionSource = originalTransition.interruptionSource;
newTransition.isExit = originalTransition.isExit;
newTransition.mute = originalTransition.mute;
newTransition.name = originalTransition.name;
newTransition.offset = originalTransition.offset;
newTransition.orderedInterruption = originalTransition.orderedInterruption;
newTransition.solo = originalTransition.solo;
optTransitions[i] = newTransition;
}
return(optTransitions);
}
/// <summary>
///
/// </summary>
/// <param name="condition"></param>
/// <returns>下位を検索するなら真</returns>
public virtual bool OnCondition(AnimatorCondition condition, int lNum, int smNum, int sNum, int tNum, int cNum)
{
return(false);
}
private void DrawAnimatorTransition(AnimatorTransitionBase transition, string source = null, CombinedAnimatorState sourceState = null, bool foldout = true)
{
// This is ugly. Apparently you can't modify the collection directly.
// The only way I found that worked was to remove conditions and readd
// on modification. There must be a better way to do it.
// TODO: Do this the right way.
List <AnimatorCondition> conditions = new List <AnimatorCondition>();
bool modified = false;
string label = GetTransitionLabel(transition, sourceState, source);
GUILayout.BeginHorizontal();
{
if (foldout)
{
foldouts[transition] = EditorGUILayout.Foldout(CollectionUtil.GetOrAdd(foldouts, transition, false), label);
}
else
{
GUILayout.Label(label);
}
if (!foldout || foldouts[transition])
{
GUILayout.FlexibleSpace();
if (GUILayout.Button("+", InspectorStyles.NoPaddingButtonStyle, GUILayout.Width(16), GUILayout.Height(16)))
{
AnimatorCondition condition = new AnimatorCondition();
condition.parameter = parameterNames[0];
conditions.Add(condition);
modified = true;
}
}
}
GUILayout.EndHorizontal();
if (!foldout || foldouts[transition])
{
for (int i = 0; i < transition.conditions.Length; i++)
{
var condition = transition.conditions[i];
bool remove;
if (DrawAnimatorCondition(ref condition, out remove))
{
if (!remove)
{
conditions.Add(condition);
}
modified = true;
}
else
{
conditions.Add(transition.conditions[i]);
}
}
if (modified)
{
while (transition.conditions.Length > 0)
{
transition.RemoveCondition(transition.conditions[0]);
}
foreach (AnimatorCondition condition in conditions)
{
transition.AddCondition(condition.mode, condition.threshold, condition.parameter);
}
}
}
}
public override void OnInspectorGUI()
{
var graph = asset.Settings;
if (GUILayout.Button("Import Mecanim Controller"))
{
ExportAnimations.CreateAsset(asset, (UnityEditor.Animations.AnimatorController)asset.controller);
EditorUtility.SetDirty(asset);
AssetDatabase.Refresh();
}
if (graph != null && graph.layers != null)
{
int layerCount = graph.layers.Length;
if (layerCount > 0)
{
string[] layerNames = new string[layerCount];
for (int l = 0; l < layerCount; l++)
{
layerNames[l] = graph.layers[l].name;
}
selectedLayer = GUILayout.Toolbar(selectedLayer, layerNames);
AnimatorLayer layer = graph.layers[selectedLayer];
if (layer != null)
{
int stateCount = layer.states.Length;
if (stateCount > 0)
{
string[] stateNames = new string[stateCount];
for (int s = 0; s < stateCount; s++)
{
stateNames[s] = layer.states[s].name;
}
selectedState = GUILayout.Toolbar(selectedState, stateNames);
AnimatorState state = layer.states[selectedState];
if (state != null)
{
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("State");
EditorGUILayout.LabelField(state.name);
EditorGUILayout.LabelField(string.Format("Is Default: {0}", state.isDefault));
if (state.motion != null)
{
EditorGUILayout.LabelField(string.Format("Is Blend Tree: {0}", state.motion.isTree));
if (!state.motion.isTree)
{
AnimatorClip motion = state.motion as AnimatorClip;
AnimationClipGui(motion);
}
else
{
AnimatorBlendTree motion = state.motion as AnimatorBlendTree;
string[] blends = new string[motion.motionCount];
for (int b = 0; b < motion.motionCount; b++)
{
blends[b] = motion.motions[b].name;
}
selectedBlend = SelectionField(blends, selectedBlend, 2);
AnimatorClip clip = motion.motions[selectedBlend] as AnimatorClip;
AnimationClipGui(clip);
}
}
else
{
EditorGUILayout.LabelField("No Motion Set");
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Transitions");
int transitionCount = state.transitions.Length;
for (int t = 0; t < transitionCount; t++)
{
EditorGUILayout.BeginVertical("Box");
AnimatorTransition transition = state.transitions[t];
EditorGUILayout.LabelField(string.Format("{0}. {1}", transition.index, transition.name));
EditorGUILayout.LabelField(string.Format("Duration: {0} sec", transition.duration.AsFloat));
EditorGUILayout.LabelField(string.Format("Has Exit Time: {0}", transition.hasExitTime));
EditorGUILayout.LabelField(string.Format("Exit Time: {0} sec", transition.exitTime.AsFloat));
EditorGUILayout.LabelField(string.Format("Destination State (Hash): {0} ({1})", transition.destinationStateName, transition.destinationStateId));
EditorGUILayout.LabelField(string.Format("Offset: {0} sec", transition.offset.AsFloat));
int conditionCount = transition.conditions.Length;
for (int c = 0; c < conditionCount; c++)
{
EditorGUILayout.BeginVertical("Box");
AnimatorCondition condition = transition.conditions[c];
AnimatorVariable variable = graph.variables[graph.VariableIndex(condition.variableName)];
string conditionMode = "";
switch (condition.mode)
{
case AnimatorCondition.Modes.Equals:
conditionMode = "==";
break;
case AnimatorCondition.Modes.Greater:
conditionMode = ">";
break;
case AnimatorCondition.Modes.If:
conditionMode = "is true";
break;
case AnimatorCondition.Modes.IfNot:
conditionMode = "is false";
break;
case AnimatorCondition.Modes.Less:
conditionMode = "<";
break;
case AnimatorCondition.Modes.NotEqual:
conditionMode = "!=";
break;
}
string threshold = "";
switch (variable.type)
{
case AnimatorVariable.VariableType.FP:
threshold = condition.thresholdFp.AsFloat.ToString();
break;
case AnimatorVariable.VariableType.Int:
threshold = condition.thresholdInt.ToString();
break;
}
EditorGUILayout.LabelField(string.Format("\"{0}\" - {1} - {2}", condition.variableName, conditionMode, threshold));
EditorGUILayout.EndVertical();
}
EditorGUILayout.EndVertical();
}
EditorGUILayout.EndVertical();
}
}
}
}
}
base.OnInspectorGUI();
}
public static bool HasCondition(this AnimatorStateTransition obj, AnimatorCondition condition)
{
var conditions = obj.conditions;
return(conditions.Any(w => condition.Equals(w)));
}
private bool DrawAnimatorCondition(ref AnimatorCondition condition, out bool remove)
{
bool modified = false;
remove = false;
EditorGUILayout.BeginHorizontal();
{
if (!nameToParameter.ContainsKey(condition.parameter))
{
string name = EditorGUILayout.TextField(condition.parameter);
if (name != condition.parameter)
{
condition.parameter = name;
modified = true;
}
AnimatorConditionMode mode = (AnimatorConditionMode)EditorGUILayout.EnumPopup(condition.mode);
if (mode != condition.mode)
{
condition.mode = mode;
modified = true;
}
string result = EditorGUILayout.TextField("" + condition.threshold);
float resultValue;
if (float.TryParse(result, out resultValue) && resultValue != condition.threshold)
{
condition.threshold = resultValue;
modified = true;
}
}
else
{
int parameterIndex = nameToParameterIndex[condition.parameter];
int index = EditorGUILayout.Popup(parameterIndex, parameterNames);
AnimatorControllerParameter parameter = parameters[index];
if (index != parameterIndex)
{
condition.parameter = parameter.name;
modified = true;
}
if (parameter.type == AnimatorControllerParameterType.Bool)
{
int selectedCondition = Math.Max(0, System.Array.IndexOf(boolConditions, condition.mode));
int conditionIdx = EditorGUILayout.Popup(selectedCondition, boolConditionNames);
if (conditionIdx != selectedCondition)
{
condition.mode = boolConditions[conditionIdx];
modified = true;
}
}
else if (parameter.type != AnimatorControllerParameterType.Trigger)
{
int selectedCondition = System.Array.IndexOf(conditionModes, condition.mode);
int conditionIdx = EditorGUILayout.Popup(selectedCondition, conditionModeNames);
if (conditionIdx != selectedCondition)
{
condition.mode = conditionModes[conditionIdx];
modified = true;
}
AnimationStateSet set = null;
if (parameter.name.EndsWith("ItemID"))
{
set = stateCollection.ItemIds;
}
else if (parameter.name.EndsWith("StateIndex"))
{
set = stateCollection.ItemStateIndexes;
}
else if (parameter.name.EndsWith("AbilityIndex"))
{
set = stateCollection.AbilityIndexes;
}
else
{
string result = EditorGUILayout.TextField("" + condition.threshold);
float resultValue;
if (float.TryParse(result, out resultValue) && resultValue != condition.threshold)
{
condition.threshold = resultValue;
modified = true;
}
}
if (null != set)
{
int id = set.DrawStateSet((int)condition.threshold);
if (id != condition.threshold)
{
condition.threshold = id;
modified = true;
}
}
}
}
if (GUILayout.Button(InspectorStyles.DeleteIcon, InspectorStyles.NoPaddingButtonStyle, GUILayout.Width(16), GUILayout.Height(16)))
{
remove = true;
modified = true;
}
}
EditorGUILayout.EndHorizontal();
return(modified);
}
// [SerializeField] public float threshold;
public ConditionJson(AnimatorCondition animatorCondition, Urho3DEngine engine, PrefabContext prefabContext)
{
this.mode = animatorCondition.mode;
this.parameter = animatorCondition.parameter;
// this.threshold = animatorCondition.threshold;
}
public ConditionDefinition AddCondition(AnimatorCondition condition)
{
return(Children.AddChild(new ConditionDefinition(this, condition)));
}
public static bool Equals(this AnimatorCondition obj1, AnimatorCondition obj2)
{
return(obj1.parameter == obj2.parameter && obj1.mode == obj2.mode && Math.Abs(obj1.threshold - obj2.threshold) == 0);
}
AnimatorStateTransition[] ProcessTransitions(AnimatorStateTransition[] transitions)
{
List <AnimatorStateTransition> transitionsToAdd = new List <AnimatorStateTransition>();
for (int t = 0; t < transitions.Length; t++)
{
List <AnimatorCondition> conditionsToAdd = new List <AnimatorCondition>();
// Debug.Log(transitions[t].conditions.Length + " conditions");
for (int c = 0; c < transitions[t].conditions.Length; c++)
{
AnimatorCondition condition = transitions[t].conditions[c];
// Debug.Log("CHECK " + condition.parameter + " " + condition.mode + " " + condition.threshold);
// TODO: Use switch
if (condition.mode == AnimatorConditionMode.Equals)
{
if (condition.parameter == "GestureLeft" || condition.parameter == "GestureRight")
{
float chilloutGestureNumber = GetChilloutGestureNumberForVrchatGestureNumber(condition.threshold);
AnimatorCondition newConditionLessThan = new AnimatorCondition();
newConditionLessThan.parameter = condition.parameter;
newConditionLessThan.mode = AnimatorConditionMode.Less;
newConditionLessThan.threshold = (float)(chilloutGestureNumber + 0.1);
conditionsToAdd.Add(newConditionLessThan);
AnimatorCondition newConditionGreaterThan = new AnimatorCondition();
newConditionGreaterThan.parameter = condition.parameter;
newConditionGreaterThan.mode = AnimatorConditionMode.Greater;
newConditionGreaterThan.threshold = (float)(chilloutGestureNumber - 0.1);
conditionsToAdd.Add(newConditionGreaterThan);
}
else
{
AnimatorCondition newConditionLessThan = new AnimatorCondition();
newConditionLessThan.parameter = condition.parameter;
newConditionLessThan.mode = AnimatorConditionMode.Less;
newConditionLessThan.threshold = (float)(condition.threshold + 0.1);
conditionsToAdd.Add(newConditionLessThan);
AnimatorCondition newConditionGreaterThan = new AnimatorCondition();
newConditionGreaterThan.parameter = condition.parameter;
newConditionGreaterThan.mode = AnimatorConditionMode.Greater;
newConditionGreaterThan.threshold = (float)(condition.threshold - 0.1);
conditionsToAdd.Add(newConditionGreaterThan);
}
}
else if (condition.mode == AnimatorConditionMode.NotEqual)
{
if (condition.parameter == "GestureLeft" || condition.parameter == "GestureRight")
{
float chilloutGestureNumber = GetChilloutGestureNumberForVrchatGestureNumber(condition.threshold);
AnimatorCondition newConditionLessThan = new AnimatorCondition();
newConditionLessThan.parameter = condition.parameter;
newConditionLessThan.mode = AnimatorConditionMode.Less;
newConditionLessThan.threshold = (float)(chilloutGestureNumber - 0.1);
conditionsToAdd.Add(newConditionLessThan);
}
else
{
AnimatorCondition newConditionLessThan = new AnimatorCondition();
newConditionLessThan.parameter = condition.parameter;
newConditionLessThan.mode = AnimatorConditionMode.Less;
newConditionLessThan.threshold = (float)(condition.threshold - 0.1);
conditionsToAdd.Add(newConditionLessThan);
AnimatorStateTransition newTransition = AnimatorStateTransition.Instantiate(transitions[t]);
newTransition.conditions = new AnimatorCondition[] {
new AnimatorCondition()
{
parameter = condition.parameter,
mode = AnimatorConditionMode.Greater,
threshold = (float)(condition.threshold + 0.1)
}
};
transitionsToAdd.Add(newTransition);
}
}
else if (condition.mode == AnimatorConditionMode.If)
{
AnimatorCondition newConditionLessThan = new AnimatorCondition();
newConditionLessThan.parameter = condition.parameter;
newConditionLessThan.mode = AnimatorConditionMode.Less;
newConditionLessThan.threshold = (float)1.1;
conditionsToAdd.Add(newConditionLessThan);
AnimatorCondition newConditionGreaterThan = new AnimatorCondition();
newConditionGreaterThan.parameter = condition.parameter;
newConditionGreaterThan.mode = AnimatorConditionMode.Greater;
newConditionGreaterThan.threshold = (float)0.5;
conditionsToAdd.Add(newConditionGreaterThan);
}
else if (condition.mode == AnimatorConditionMode.IfNot)
{
AnimatorCondition newConditionLessThan = new AnimatorCondition();
newConditionLessThan.parameter = condition.parameter;
newConditionLessThan.mode = AnimatorConditionMode.Less;
newConditionLessThan.threshold = (float)0.49;
conditionsToAdd.Add(newConditionLessThan);
AnimatorCondition newConditionGreaterThan = new AnimatorCondition();
newConditionGreaterThan.parameter = condition.parameter;
newConditionGreaterThan.mode = AnimatorConditionMode.Greater;
newConditionGreaterThan.threshold = (float)-0.1;
conditionsToAdd.Add(newConditionGreaterThan);
}
else if (condition.mode == AnimatorConditionMode.Greater)
{
AnimatorCondition newCondition = new AnimatorCondition();
newCondition.parameter = condition.parameter;
newCondition.mode = AnimatorConditionMode.Greater;
newCondition.threshold = condition.threshold;
conditionsToAdd.Add(newCondition);
}
else if (condition.mode == AnimatorConditionMode.Less)
{
AnimatorCondition newCondition = new AnimatorCondition();
newCondition.parameter = condition.parameter;
newCondition.mode = AnimatorConditionMode.Less;
newCondition.threshold = condition.threshold;
conditionsToAdd.Add(newCondition);
}
}
transitions[t].conditions = conditionsToAdd.ToArray();
}
AnimatorStateTransition[] newTransitions = new AnimatorStateTransition[transitions.Length + transitionsToAdd.Count];
transitions.CopyTo(newTransitions, 0);
transitionsToAdd.ToArray().CopyTo(newTransitions, transitions.Length);
return(newTransitions);
}
/// <summary>
/// 显示过渡条件
/// </summary>
/// <param name="state">State.</param>
/// <param name="transitions">Transitions.</param>
public void ShowTransitionConditionGUI(AnimatorState state, AnimatorStateTransition[] transitions)
{
GUILayout.BeginVertical();
{
for (int i = 0; i < transitions.Length; i++)
{
AnimatorStateTransition transition = transitions[i];
GUILayout.BeginHorizontal();
{
GUILayout.Space(50f);
GUILayout.Label(state.name + "-> " + transition.destinationState.name);
AnimatorCondition[] conditions = transition.conditions;
for (int j = 0; j < conditions.Length; j++)
{
AnimatorCondition condition = conditions[j];//结构体值拷贝
int selectedParameterIndex = listStrParameter.FindIndex(str => str == condition.parameter);
AnimatorControllerParameter parameter = listParameter[selectedParameterIndex];
//显示
int newSelectedParameterIndex = EditorGUILayout.Popup(selectedParameterIndex, listStrParameter.ToArray());
AnimatorConditionMode mode = condition.mode;
float threshold = condition.threshold;
ModeAndThresholdPopUp(ref mode, ref threshold, parameter.type);
if (j < conditions.Length - 1)
{
GUILayout.Label("&&");
}
GUILayout.FlexibleSpace();//使左对齐
//保存
if (newSelectedParameterIndex != selectedParameterIndex)
{
condition.parameter = listStrParameter[newSelectedParameterIndex];
AnimatorControllerParameter selectedParameter = listParameter[newSelectedParameterIndex];
switch (selectedParameter.type)
{
case AnimatorControllerParameterType.Bool:
condition.mode = AnimatorConditionMode.If;
condition.threshold = 0f;
break;
case AnimatorControllerParameterType.Int:
condition.mode = AnimatorConditionMode.Equals;
condition.threshold = (float)selectedParameter.defaultInt;
break;
case AnimatorControllerParameterType.Float:
condition.mode = AnimatorConditionMode.Greater;
condition.threshold = selectedParameter.defaultFloat;
break;
case AnimatorControllerParameterType.Trigger:
condition.mode = AnimatorConditionMode.If;
condition.threshold = 0f;
break;
}
conditions[j] = condition;
transition.conditions = conditions;
}
else if (mode != condition.mode || threshold > condition.threshold || threshold < condition.threshold)
{
condition.mode = mode;
condition.threshold = threshold;
conditions[j] = condition;
transition.conditions = conditions;
}
}
}
GUILayout.EndHorizontal();
}
}
GUILayout.EndVertical();
}
