private void BuildDestinationStatesRecursive(AnimatorTransitionBase transition, AnimatorStateMachine rootStateMachine, AnimatorStateMachine currentStateMachine)
{
if (transition.destinationState)
{
this.m_DstStates.Add(transition.destinationState);
}
else if (transition.isExit)
{
AnimatorStateMachine animatorStateMachine = rootStateMachine.FindParent(currentStateMachine);
if (animatorStateMachine != null)
{
AnimatorTransition[] stateMachineTransitions = animatorStateMachine.GetStateMachineTransitions(currentStateMachine);
AnimatorTransition[] array = stateMachineTransitions;
for (int i = 0; i < array.Length; i++)
{
AnimatorTransition transition2 = array[i];
this.BuildDestinationStatesRecursive(transition2, rootStateMachine, animatorStateMachine);
}
}
}
else if (transition.destinationStateMachine)
{
if (transition.destinationStateMachine.defaultState != null)
{
this.m_DstStates.Add(transition.destinationStateMachine.defaultState);
}
AnimatorTransition[] entryTransitions = transition.destinationStateMachine.entryTransitions;
AnimatorTransition[] array2 = entryTransitions;
for (int j = 0; j < array2.Length; j++)
{
AnimatorTransition transition3 = array2[j];
this.BuildDestinationStatesRecursive(transition3, rootStateMachine, transition.destinationStateMachine);
}
}
}
protected void ComputeTransitionContexts()
{
this.m_TransitionContexts = new TransitionEditionContext[base.targets.Length];
UnityEditor.Graphs.AnimationStateMachine.Graph graph = (AnimatorControllerTool.tool == null) ? null : AnimatorControllerTool.tool.stateMachineGraph;
UnityEditor.Graphs.AnimationStateMachine.GraphGUI hgui = (AnimatorControllerTool.tool == null) ? null : AnimatorControllerTool.tool.stateMachineGraphGUI;
for (int i = 0; i < base.targets.Length; i++)
{
AnimatorTransitionBase aTransition = base.targets[i] as AnimatorTransitionBase;
this.m_TransitionContexts[i] = new TransitionEditionContext(aTransition, null, null, null);
if ((graph != null) && (hgui != null))
{
foreach (int num2 in hgui.edgeGUI.edgeSelection)
{
EdgeInfo edgeInfo = graph.GetEdgeInfo(graph.edges[num2]);
foreach (TransitionEditionContext context in edgeInfo.transitions)
{
if (context.transition == aTransition)
{
this.m_TransitionContexts[i] = context;
}
}
}
}
}
}
public static AnimatorTransitionBase DeepClone(this AnimatorTransitionBase transition)
{
AnimatorTransitionBase output = UnityEngine.Object.Instantiate(transition);
EditorUtility.CopySerialized(transition, output);
return(output);
}
protected void ComputeTransitionContexts()
{
this.m_TransitionContexts = new TransitionEditionContext[base.targets.Length];
Graph graph = (!AnimatorControllerTool.tool) ? null : AnimatorControllerTool.tool.stateMachineGraph;
GraphGUI graphGUI = (!AnimatorControllerTool.tool) ? null : AnimatorControllerTool.tool.stateMachineGraphGUI;
for (int i = 0; i < base.targets.Length; i++)
{
AnimatorTransitionBase animatorTransitionBase = base.targets[i] as AnimatorTransitionBase;
this.m_TransitionContexts[i] = new TransitionEditionContext(animatorTransitionBase, null, null, null);
if (graph != null && graphGUI != null)
{
foreach (int current in graphGUI.edgeGUI.edgeSelection)
{
EdgeInfo edgeInfo = graph.GetEdgeInfo(graph.edges[current]);
foreach (TransitionEditionContext current2 in edgeInfo.transitions)
{
if (current2.transition == animatorTransitionBase)
{
this.m_TransitionContexts[i] = current2;
}
}
}
}
}
}
private void BuildDestinationStatesRecursive(AnimatorTransitionBase transition, AnimatorStateMachine rootStateMachine, AnimatorStateMachine currentStateMachine)
{
if (transition.destinationState != null)
{
this.m_DstStates.Add(transition.destinationState);
}
else if (transition.isExit)
{
AnimatorStateMachine machine = rootStateMachine.FindParent(currentStateMachine);
if (machine != null)
{
AnimatorTransition[] stateMachineTransitions = machine.GetStateMachineTransitions(currentStateMachine);
foreach (AnimatorTransition transition2 in stateMachineTransitions)
{
this.BuildDestinationStatesRecursive(transition2, rootStateMachine, machine);
}
}
}
else if ((transition.destinationStateMachine != null) && !this.m_DstStateMachines.Contains(transition.destinationStateMachine))
{
this.m_DstStateMachines.Add(transition.destinationStateMachine);
if (transition.destinationStateMachine.defaultState != null)
{
this.m_DstStates.Add(transition.destinationStateMachine.defaultState);
}
AnimatorTransition[] entryTransitions = transition.destinationStateMachine.entryTransitions;
foreach (AnimatorTransition transition3 in entryTransitions)
{
this.BuildDestinationStatesRecursive(transition3, rootStateMachine, transition.destinationStateMachine);
}
}
}
public TransitionEditionContext(AnimatorTransitionBase aTransition, AnimatorState aSourceState, AnimatorStateMachine aSourceStateMachine, AnimatorStateMachine aOwnerStateMachine)
{
this.transition = aTransition;
this.sourceState = aSourceState;
this.sourceStateMachine = aSourceStateMachine;
this.ownerStateMachine = aOwnerStateMachine;
this.BuildNames();
}
AddCondition(
this AnimatorTransitionBase transition,
AnimatorCondition condition)
{
AnimatorCondition[] temp = transition.conditions;
ArrayUtility.Add(ref temp, condition);
transition.conditions = temp;
}
public static AnimatorTransitionBase DeepClone(this AnimatorTransitionBase transition, ChildAnimatorState childState)
{
AnimatorTransitionBase output = UnityEngine.Object.Instantiate(transition);
EditorUtility.CopySerialized(transition, output);
output.destinationState = childState.state;
return(output);
}
public bool HasTransition(AnimatorTransitionBase transition)
{
foreach (TransitionEditionContext current in this.transitions)
{
if (current.transition == transition)
{
return(true);
}
}
return(false);
}
protected void RemoveAllAndAddCondition(AnimatorTransitionBase transition, string paramName, AnimatorConditionMode mode, float threshold)
{
foreach (AnimatorCondition condition in transition.conditions)
{
if (condition.parameter == paramName)
{
transition.RemoveCondition(condition);
}
}
transition.AddCondition(mode, threshold, paramName);
}
private void OnRemoveParameter(int index)
{
if (this.m_Host.liveLink)
{
return;
}
if (this.m_ParameterList.list.Count <= 0)
{
return;
}
ParameterControllerView.Element element = this.m_ParameterList.list[index] as ParameterControllerView.Element;
List <UnityEngine.Object> list = this.m_Host.animatorController.CollectObjectsUsingParameter(element.name).ToList <UnityEngine.Object>();
bool flag = false;
if (list.Count > 0)
{
string title = "Delete parameter " + element.name + "?";
string text = "It is used by : \n";
foreach (UnityEngine.Object current in list)
{
AnimatorTransitionBase animatorTransitionBase = current as AnimatorTransitionBase;
if (animatorTransitionBase != null && animatorTransitionBase.destinationState != null)
{
text = text + "Transition to " + animatorTransitionBase.destinationState.name + "\n";
}
else if (animatorTransitionBase != null && animatorTransitionBase.destinationStateMachine != null)
{
text = text + "Transition to " + animatorTransitionBase.destinationStateMachine.name + "\n";
}
else
{
text = text + current.name + "\n";
}
}
if (EditorUtility.DisplayDialog(title, text, "Delete", "Cancel"))
{
flag = true;
}
}
else
{
flag = true;
}
if (flag)
{
this.ResetTextFields();
list.Add(this.m_Host.animatorController);
Undo.RegisterCompleteObjectUndo(list.ToArray(), "Parameter removed");
this.m_Host.animatorController.RemoveParameter(element.m_Parameter);
this.RebuildList();
this.m_ParameterList.GrabKeyboardFocus();
}
}
public override void SyncGraphToUnitySelection()
{
if (GUIUtility.hotControl != 0)
{
return;
}
this.selection.Clear();
this.edgeGUI.edgeSelection.Clear();
UnityEngine.Object[] objects = Selection.objects;
for (int i = 0; i < objects.Length; i++)
{
UnityEngine.Object @object = objects[i];
Node node = null;
AnimatorState animatorState = @object as AnimatorState;
AnimatorStateMachine animatorStateMachine = @object as AnimatorStateMachine;
AnimatorTransitionBase animatorTransitionBase = @object as AnimatorTransitionBase;
if (animatorState != null)
{
node = this.stateMachineGraph.FindNode(animatorState);
}
else if (animatorStateMachine != null)
{
node = this.stateMachineGraph.FindNode(animatorStateMachine);
}
else if (animatorTransitionBase != null)
{
foreach (Edge current in this.m_Graph.edges)
{
EdgeInfo edgeInfo = this.stateMachineGraph.GetEdgeInfo(current);
foreach (TransitionEditionContext current2 in edgeInfo.transitions)
{
if (current2.transition == animatorTransitionBase)
{
int item = this.m_Graph.edges.IndexOf(current);
if (!this.edgeGUI.edgeSelection.Contains(item))
{
this.edgeGUI.edgeSelection.Add(item);
}
}
}
}
}
else
{
node = (@object as Node);
}
if (node != null)
{
this.selection.Add(node);
}
}
}
public TransitionDefinition(IAnimationDefinition parent, AnimatorTransitionBase transition, StateDefinition from, StateDefinition to)
{
StateTransition = transition;
Name = string.IsNullOrEmpty(transition.name) ? parent.Name : transition.name;
Parent = parent;
From = from;
To = to;
foreach (AnimatorCondition condition in transition.conditions)
{
AddCondition(condition);
}
}
protected override void SetTransitionToInspect(AnimatorTransitionBase transition)
{
base.SetTransitionToInspect(transition);
if (this.m_Controller != null)
{
AnimatorStateMachine stateMachine = this.m_Controller.layers[this.m_LayerIndex].stateMachine;
AnimatorState sourceState = this.GetSourceState(this.m_TransitionList.index);
if (sourceState)
{
this.m_DstStates = new List <AnimatorState>();
this.BuildDestinationStatesRecursive(transition, stateMachine, sourceState.FindParent(stateMachine));
}
}
}
public static AnimatorTransitionBase CloneTransition(this AnimatorTransitionBase transition, ChildAnimatorState[] states)
{
AnimatorTransitionBase output = Object.Instantiate(transition);
EditorUtility.CopySerialized(transition, output);
for (int i = 0; i < states.Length; i++)
{
if (output.destinationState != null && output.destinationState.name == states[i].state.name)
{
output.destinationState = states[i].state;
break;
}
}
return(output);
}
private void OnRemoveParameter(int index)
{
if (!this.m_Host.liveLink && (this.m_ParameterList.list.Count > 0))
{
Element element = this.m_ParameterList.list[index] as Element;
List <UnityEngine.Object> list = this.m_Host.animatorController.CollectObjectsUsingParameter(element.name).ToList <UnityEngine.Object>();
bool flag = false;
if (list.Count > 0)
{
string title = "Delete parameter " + element.name + "?";
string message = "It is used by : \n";
foreach (UnityEngine.Object obj2 in list)
{
AnimatorTransitionBase base2 = obj2 as AnimatorTransitionBase;
if ((base2 != null) && (base2.destinationState != null))
{
message = message + "Transition to " + base2.destinationState.name + "\n";
}
else if ((base2 != null) && (base2.destinationStateMachine != null))
{
message = message + "Transition to " + base2.destinationStateMachine.name + "\n";
}
else
{
message = message + obj2.name + "\n";
}
}
if (EditorUtility.DisplayDialog(title, message, "Delete", "Cancel"))
{
flag = true;
}
}
else
{
flag = true;
}
if (flag)
{
this.ResetTextFields();
list.Add(this.m_Host.animatorController);
Undo.RegisterCompleteObjectUndo(list.ToArray(), "Parameter removed");
this.m_Host.animatorController.RemoveParameter(element.m_Parameter);
this.RebuildList();
this.m_ParameterList.GrabKeyboardFocus();
}
}
}
/// <summary>
/// Generates the code to recreate the specified transition.
/// </summary>
/// <param name="stateMachineName">The name of the state machine variable that the transition has been added to.</param>
/// <param name="transition">The transition to generate the code of.</param>
/// <param name="isStateTransition">Is the transition a state transition?</param>
/// <param name="isAnyStateTransition">Is the transition an AnyState transition?</param>
/// <param name="generatedCode">The final generated code.</param>
private static void GenerateTransition(string stateMachineName, AnimatorTransitionBase transition, bool isStateTransition, bool isAnyStateTransition, StringBuilder generatedCode)
{
if (transition.destinationState == null && !transition.isExit)
{
return;
}
var transitionName = UniqueName(transition);
if (isStateTransition || isAnyStateTransition)
{
if (isAnyStateTransition)
{
generatedCode.AppendLine("\t\t\tvar " + transitionName + " = " + stateMachineName + ".AddAnyStateTransition(" + UniqueName(transition.destinationState) + ");");
}
else if (transition.isExit)
{
generatedCode.AppendLine("\t\t\tvar " + transitionName + " = " + stateMachineName + ".AddExitTransition();");
}
else
{
generatedCode.AppendLine("\t\t\tvar " + transitionName + " = " + stateMachineName + ".AddTransition(" + UniqueName(transition.destinationState) + ");");
}
var stateTransition = transition as AnimatorStateTransition;
generatedCode.AppendLine("\t\t\t" + transitionName + ".canTransitionToSelf = " + BoolString(stateTransition.canTransitionToSelf) + ";");
generatedCode.AppendLine("\t\t\t" + transitionName + ".duration = " + stateTransition.duration + "f;");
generatedCode.AppendLine("\t\t\t" + transitionName + ".exitTime = " + stateTransition.exitTime + "f;");
generatedCode.AppendLine("\t\t\t" + transitionName + ".hasExitTime = " + BoolString(stateTransition.hasExitTime) + ";");
generatedCode.AppendLine("\t\t\t" + transitionName + ".hasFixedDuration = " + BoolString(stateTransition.hasFixedDuration) + ";");
generatedCode.AppendLine("\t\t\t" + transitionName + ".interruptionSource = TransitionInterruptionSource." + stateTransition.interruptionSource + ";");
generatedCode.AppendLine("\t\t\t" + transitionName + ".offset = " + stateTransition.offset + "f;");
generatedCode.AppendLine("\t\t\t" + transitionName + ".orderedInterruption = " + BoolString(stateTransition.orderedInterruption) + ";");
}
else
{
generatedCode.AppendLine("\t\t\tvar " + transitionName + " = " + stateMachineName + ".AddEntryTransition(" + UniqueName(transition.destinationState) + ");");
}
generatedCode.AppendLine("\t\t\t" + transitionName + ".isExit = " + BoolString(transition.isExit) + ";");
generatedCode.AppendLine("\t\t\t" + transitionName + ".mute = " + BoolString(transition.mute) + ";");
generatedCode.AppendLine("\t\t\t" + transitionName + ".solo = " + BoolString(transition.solo) + ";");
for (int i = 0; i < transition.conditions.Length; ++i)
{
generatedCode.AppendLine("\t\t\t" + transitionName + ".AddCondition(AnimatorConditionMode." + transition.conditions[i].mode.ToString() + ", " +
transition.conditions[i].threshold + "f, \"" + transition.conditions[i].parameter + "\");");
}
}
private void AddConditionInList(ReorderableList list)
{
AnimatorTransitionBase animatorTransitionBase = this.m_SerializedTransition.targetObject as AnimatorTransitionBase;
string parameter = string.Empty;
AnimatorConditionMode mode = AnimatorConditionMode.Greater;
if (this.m_Controller)
{
UnityEngine.AnimatorControllerParameter[] parameters = this.m_Controller.parameters;
if (parameters.Length > 0)
{
parameter = parameters[0].name;
mode = ((parameters[0].type != UnityEngine.AnimatorControllerParameterType.Float && parameters[0].type != UnityEngine.AnimatorControllerParameterType.Int) ? AnimatorConditionMode.If : AnimatorConditionMode.Greater);
}
}
animatorTransitionBase.AddCondition(mode, 0f, parameter);
}
private void AddConditionInList(ReorderableList list)
{
AnimatorTransitionBase targetObject = this.m_SerializedTransition.targetObject as AnimatorTransitionBase;
string parameter = "";
AnimatorConditionMode greater = AnimatorConditionMode.Greater;
if (this.m_Controller != null)
{
UnityEngine.AnimatorControllerParameter[] parameters = this.m_Controller.parameters;
if (parameters.Length > 0)
{
parameter = parameters[0].name;
greater = ((parameters[0].type != UnityEngine.AnimatorControllerParameterType.Float) && (parameters[0].type != UnityEngine.AnimatorControllerParameterType.Int)) ? AnimatorConditionMode.If : AnimatorConditionMode.Greater;
}
}
targetObject.AddCondition(greater, 0f, parameter);
}
protected virtual void SetTransitionToInspect(AnimatorTransitionBase transition)
{
if ((this.m_SerializedTransition != null && this.m_SerializedTransition.targetObject == transition) || transition == null)
{
return;
}
this.m_SerializedTransition = new SerializedObject(transition);
if (this.m_SerializedTransition == null)
{
return;
}
this.InitSerializedProperties();
this.m_ConditionList = new ReorderableList(this.m_SerializedTransition, this.m_Conditions);
this.m_ConditionList.drawElementCallback = new ReorderableList.ElementCallbackDelegate(this.DrawConditionsElement);
this.m_ConditionList.onAddCallback = new ReorderableList.AddCallbackDelegate(this.AddConditionInList);
this.m_ConditionList.drawHeaderCallback = new ReorderableList.HeaderCallbackDelegate(this.DrawConditionsHeader);
}
private void SelectTransition(ReorderableList list)
{
AnimatorTransitionBase transition = this.m_Transitions[list.index].transition;
if (transition == null)
{
return;
}
if (this.m_Type == TransitionType.eState || this.m_Type == TransitionType.eAnyState)
{
this.m_TransitionInspector = (Editor.CreateEditor(transition as AnimatorStateTransition) as AnimatorStateTransitionInspector);
}
else
{
this.m_TransitionInspector = (Editor.CreateEditor(transition as AnimatorTransition) as AnimatorTransitionInspector);
}
this.m_TransitionInspector.SetTransitionContext(this.m_Transitions[list.index]);
this.m_TransitionInspector.showTransitionList = false;
}
private void BuildNames()
{
if (this.sourceState != null)
{
this.m_DisplayName = this.transition.GetDisplayName(this.sourceState);
}
else if (this.sourceStateMachine != null)
{
this.m_DisplayName = this.transition.GetDisplayName(this.sourceStateMachine);
}
else if (this.transition != null)
{
this.m_DisplayName = this.transition.GetDisplayName(null);
}
else
{
this.m_DisplayName = "To Default State";
}
this.m_FullName = "";
if (((AnimatorControllerTool.tool != null) && (AnimatorControllerTool.tool.stateMachineGraph != null)) && ((AnimatorControllerTool.tool.stateMachineGraph.rootStateMachine != null) && (this.transition != null)))
{
string source = !this.isAnyStateTransition ? "" : "AnyState";
string destination = "";
UnityEditor.Graphs.AnimationStateMachine.Graph stateMachineGraph = AnimatorControllerTool.tool.stateMachineGraph;
if (this.sourceState != null)
{
source = stateMachineGraph.GetStatePath(this.sourceState);
}
else if (this.sourceStateMachine != null)
{
source = stateMachineGraph.GetStateMachinePath(this.sourceStateMachine);
}
if (this.transition.destinationState != null)
{
destination = destination + stateMachineGraph.GetStatePath(this.transition.destinationState);
}
else if (this.transition.destinationStateMachine != null)
{
destination = destination + stateMachineGraph.GetStateMachinePath(this.transition.destinationStateMachine);
}
this.m_FullName = AnimatorTransitionBase.BuildTransitionName(source, destination);
}
}
private void BuildNames()
{
if (this.sourceState)
{
this.m_DisplayName = this.transition.GetDisplayName(this.sourceState);
}
else if (this.sourceStateMachine)
{
this.m_DisplayName = this.transition.GetDisplayName(this.sourceStateMachine);
}
else if (this.transition)
{
this.m_DisplayName = this.transition.GetDisplayName(null);
}
else
{
this.m_DisplayName = "To Default State";
}
this.m_FullName = string.Empty;
if (AnimatorControllerTool.tool && AnimatorControllerTool.tool.stateMachineGraph && AnimatorControllerTool.tool.stateMachineGraph.rootStateMachine && this.transition != null)
{
string source = (!this.isAnyStateTransition) ? string.Empty : "AnyState";
string text = string.Empty;
Graph stateMachineGraph = AnimatorControllerTool.tool.stateMachineGraph;
if (this.sourceState)
{
source = stateMachineGraph.GetStatePath(this.sourceState);
}
else if (this.sourceStateMachine)
{
source = stateMachineGraph.GetStateMachinePath(this.sourceStateMachine);
}
if (this.transition.destinationState)
{
text += stateMachineGraph.GetStatePath(this.transition.destinationState);
}
else if (this.transition.destinationStateMachine)
{
text += stateMachineGraph.GetStateMachinePath(this.transition.destinationStateMachine);
}
this.m_FullName = AnimatorTransitionBase.BuildTransitionName(source, text);
}
}
private string GetTransitionLabel(AnimatorTransitionBase transition, CombinedAnimatorState state = null, string source = null)
{
string label = (source ?? "Self") + " -> ";
if (null != state && state.HasTransition(transition))
{
label += "Self";
}
else if (null != transition.destinationState)
{
label += transition.destinationState.name;
}
else if (null != transition.destinationStateMachine)
{
label += transition.destinationStateMachine.name;
}
else if (transition.isExit)
{
label += "Exit";
}
return(label);
}
public static AnimatorTransitionBase DeepClone(this AnimatorTransitionBase transition, ChildAnimatorState[] states, ChildAnimatorStateMachine[] machines)
{
AnimatorTransitionBase output = UnityEngine.Object.Instantiate(transition);
EditorUtility.CopySerialized(transition, output);
for (int i = 0; i < states.Length && output.destinationState != null; i++)
{
if (output.destinationState.name == states[i].state.name)
{
output.destinationState = states[i].state;
break;
}
}
for (int i = 0; i < machines.Length && output.destinationStateMachine != null; i++)
{
if (output.destinationStateMachine.name == machines[i].stateMachine.name)
{
output.destinationStateMachine = machines[i].stateMachine;
break;
}
}
return(output);
}
public TransitionDefinition AddTransition(AnimatorTransitionBase transition, StateDefinition from, StateDefinition to)
{
return(Children.AddChild(new TransitionDefinition(this, transition, from, to)));
}
private static Example.StateMachineTransaction ExportTransaction(AnimatorController controller, List <Example.StateMachineTransaction> transList, AnimatorTransitionBase transition, int fromState, int toState)
{
Example.StateMachineTransaction trans = new Example.StateMachineTransaction();
trans.FromState = fromState;
trans.ToState = toState;
trans.Id = transList.Count;
trans.IsExit = transition.isExit;
trans.IsMute = transition.mute;
trans.IsSolo = transition.solo;
List <Example.StateMachineTransactionCondition> conditionList = new List <Example.StateMachineTransactionCondition> ();
foreach (var condition in transition.conditions)
{
var stCondition = new Example.StateMachineTransactionCondition();
stCondition.What = condition.parameter;
stCondition.Value = condition.threshold;
//Debug.LogFormat ("transition {0} {1} {2} {3} ",transition.name,condition.parameter,condition.mode,condition.threshold);
switch (condition.mode)
{
case AnimatorConditionMode.Equals:
stCondition.Type = Example.StateMachineTransactionCondition.ConditionType.EQUAL;
break;
case AnimatorConditionMode.NotEqual:
stCondition.Type = Example.StateMachineTransactionCondition.ConditionType.NOT_EQUAL;
break;
case AnimatorConditionMode.Greater:
stCondition.Type = Example.StateMachineTransactionCondition.ConditionType.GREATER;
break;
case AnimatorConditionMode.Less:
stCondition.Type = Example.StateMachineTransactionCondition.ConditionType.LESS;
break;
case AnimatorConditionMode.If:
stCondition.Type = Example.StateMachineTransactionCondition.ConditionType.IF;
break;
case AnimatorConditionMode.IfNot:
stCondition.Type = Example.StateMachineTransactionCondition.ConditionType.IF_NOT;
break;
default:
foreach (var param in controller.parameters)
{
if (param.name == condition.parameter)
{
if (param.type == AnimatorControllerParameterType.Trigger)
{
stCondition.Type = Example.StateMachineTransactionCondition.ConditionType.TRIGGER;
}
break;
}
}
break;
}
conditionList.Add(stCondition);
}
trans.Conditions = conditionList;
transList.Add(trans);
return(trans);
}
private static Example.StateMachineTransaction ExportTransaction(AnimatorController controller, List <Example.StateMachineTransaction> transList, AnimatorTransitionBase transition, int fromState, Dictionary <Object, Example.StateMachineNode> nodes)
{
Example.StateMachineNode toState = null;
if (transition.destinationState != null)
{
toState = nodes[transition.destinationState];
}
else if (transition.destinationStateMachine != null)
{
toState = nodes[transition.destinationStateMachine];
}
return(ExportTransaction(controller, transList, transition, fromState, toState != null?toState.Id:-1));
}
private static AnimatorStateMachine FindMatchingStateMachine(List <AnimatorStateMachine> old, List <AnimatorStateMachine> n, AnimatorTransitionBase transition)
{
for (int i = 0; i < old.Count; i++)
{
if (transition.destinationStateMachine == old[i])
{
return(n[i]);
}
}
return(null);
}
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);
}
}
}
}
