private void CreateSelectorEdges(AnimatorTransition transition, AnimatorStateMachine owner, AnimatorStateMachine sourceStateMachine)
{
Node node = this.FindNodeForEdges(sourceStateMachine);
if (node is EntryNode)
{
return;
}
Node dstNode = null;
if (transition.destinationStateMachine != null)
{
dstNode = this.FindNodeForEdges(transition.destinationStateMachine);
}
else if (transition.destinationState)
{
dstNode = this.FindNodeForEdges(transition.destinationState);
}
else if (transition.isExit)
{
dstNode = this.m_ExitNode;
}
StateMachineNode stateMachineNode = node as StateMachineNode;
if (transition.isExit && node && stateMachineNode != null && stateMachineNode.stateMachine != sourceStateMachine)
{
return;
}
this.CreateEdges(node, dstNode, new TransitionEditionContext(transition, null, sourceStateMachine, owner));
}
public PPtr <AnimatorTransition>[] CreateEntryTransitions(VirtualSerializedFile file, Parameters parameters)
{
if (IsReadConstantArray(parameters.Version))
{
foreach (OffsetPtr <SelectorStateConstant> selectorPtr in SelectorStateConstantArray)
{
SelectorStateConstant selector = selectorPtr.Instance;
if (selector.FullPathID == parameters.ID && selector.IsEntry)
{
PPtr <AnimatorTransition>[] transitions = new PPtr <AnimatorTransition> [selector.TransitionConstantArray.Count - 1];
for (int i = 0; i < selector.TransitionConstantArray.Count - 1; i++)
{
SelectorTransitionConstant selectorTrans = selector.TransitionConstantArray[i].Instance;
AnimatorTransition.Parameters transParameters = new AnimatorTransition.Parameters
{
StateMachine = this,
States = parameters.States,
TOS = parameters.TOS,
Transition = selectorTrans,
Version = parameters.Version,
};
AnimatorTransition transition = AnimatorTransition.CreateVirtualInstance(file, transParameters);
transitions[i] = transition.File.CreatePPtr(transition);
}
return(transitions);
}
}
}
return(new PPtr <AnimatorTransition> [0]);
}
private void CreateSelectorEdges(AnimatorTransition transition, AnimatorStateMachine owner, AnimatorStateMachine sourceStateMachine)
{
UnityEditor.Graphs.AnimationStateMachine.Node srcNode = this.FindNodeForEdges(sourceStateMachine);
if (!(srcNode is EntryNode))
{
UnityEditor.Graphs.AnimationStateMachine.Node dstNode = null;
if (transition.destinationStateMachine != null)
{
dstNode = this.FindNodeForEdges(transition.destinationStateMachine);
}
else if (transition.destinationState != null)
{
dstNode = this.FindNodeForEdges(transition.destinationState);
}
else if (transition.isExit)
{
dstNode = this.m_ExitNode;
}
StateMachineNode node3 = srcNode as StateMachineNode;
if ((!transition.isExit || (srcNode == null)) || ((node3 == null) || (node3.stateMachine == sourceStateMachine)))
{
this.CreateEdges(srcNode, dstNode, new TransitionEditionContext(transition, null, sourceStateMachine, owner));
}
}
}
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);
}
}
}
private void CreateEdges()
{
this.m_ConnectedSlotsCache.Clear();
List <ChildAnimatorState> statesRecursive = this.rootStateMachine.statesRecursive;
foreach (ChildAnimatorState current in statesRecursive)
{
AnimatorState state = current.state;
AnimatorStateTransition[] transitions = state.transitions;
AnimatorStateTransition[] array = transitions;
for (int i = 0; i < array.Length; i++)
{
AnimatorStateTransition animatorStateTransition = array[i];
if (animatorStateTransition != null)
{
this.CreateStateEdges(state, animatorStateTransition);
}
}
}
List <AnimatorStateTransition> anyStateTransitionsRecursive = this.rootStateMachine.anyStateTransitionsRecursive;
foreach (AnimatorStateTransition current2 in anyStateTransitionsRecursive)
{
if (current2 != null)
{
this.CreateAnyStateEdges(current2);
}
}
List <ChildAnimatorStateMachine> stateMachinesRecursive = this.rootStateMachine.stateMachinesRecursive;
stateMachinesRecursive.Add(new ChildAnimatorStateMachine
{
stateMachine = this.rootStateMachine
});
foreach (ChildAnimatorStateMachine current3 in stateMachinesRecursive)
{
ChildAnimatorStateMachine[] stateMachines = current3.stateMachine.stateMachines;
ChildAnimatorStateMachine[] array2 = stateMachines;
for (int j = 0; j < array2.Length; j++)
{
ChildAnimatorStateMachine childAnimatorStateMachine = array2[j];
AnimatorTransition[] stateMachineTransitions = current3.stateMachine.GetStateMachineTransitions(childAnimatorStateMachine.stateMachine);
AnimatorTransition[] array3 = stateMachineTransitions;
for (int k = 0; k < array3.Length; k++)
{
AnimatorTransition transition = array3[k];
this.CreateSelectorEdges(transition, current3.stateMachine, childAnimatorStateMachine.stateMachine);
}
}
}
AnimatorTransition[] entryTransitions = this.activeStateMachine.entryTransitions;
AnimatorTransition[] array4 = entryTransitions;
for (int l = 0; l < array4.Length; l++)
{
AnimatorTransition transition2 = array4[l];
this.CreateEntryEdges(transition2, this.activeStateMachine);
}
this.CreateDefaultStateEdge(this.activeStateMachine.defaultState, this.activeStateMachine);
}
public AnimatorControllerExportCollection(IAssetExporter assetExporter, VirtualSerializedFile virtualFile, AnimatorController asset) :
base(assetExporter, asset)
{
ControllerConstant controller = asset.Controller;
IReadOnlyList <OffsetPtr <StateMachineConstant> > stateMachinesConst = controller.StateMachineArray;
StateMachines = new AnimatorStateMachine[stateMachinesConst.Count];
for (int i = 0; i < stateMachinesConst.Count; i++)
{
AnimatorStateMachine stateMachine = AnimatorStateMachine.CreateVirtualInstance(virtualFile, asset, i);
StateMachines[i] = stateMachine;
}
for (int i = 0; i < StateMachines.Length; i++)
{
AnimatorStateMachine stateMachine = StateMachines[i];
StateMachineConstant stateMachineConstant = asset.Controller.StateMachineArray[i].Instance;
AddAsset(stateMachine);
AddBehaviours(asset, stateMachine.StateMachineBehaviours);
foreach (PPtr <AnimatorStateTransition> transitionPtr in stateMachine.AnyStateTransitions)
{
AnimatorStateTransition transition = transitionPtr.GetAsset(virtualFile);
AddAsset(transition);
}
foreach (PPtr <AnimatorTransition> transitionPtr in stateMachine.EntryTransitions)
{
AnimatorTransition transition = transitionPtr.GetAsset(virtualFile);
AddAsset(transition);
}
for (int j = 0; j < stateMachine.ChildStates.Length; j++)
{
PPtr <AnimatorState> statePtr = stateMachine.ChildStates[j].State;
AnimatorState state = statePtr.GetAsset(virtualFile);
StateConstant stateConstant = stateMachineConstant.StateConstantArray[j].Instance;
AddAsset(state);
AddBehaviours(asset, state.StateMachineBehaviours);
if (state.Motion.IsVirtual)
{
Motion motion = state.Motion.GetAsset(virtualFile);
AddBlendTree(virtualFile, (BlendTree)motion);
}
for (int k = 0; k < state.Transitions.Length; k++)
{
PPtr <AnimatorStateTransition> transitionPtr = state.Transitions[k];
AnimatorStateTransition transition = transitionPtr.GetAsset(virtualFile);
TransitionConstant transitionConstant = stateConstant.TransitionConstantArray[k].Instance;
AddAsset(transition);
}
}
}
}
public override void InitNode(AnimationInstancing pAnimator)
{
motionIndex = pAnimator.FindAnimationInfo(motionHash);
animatorTransitions = new AnimatorTransition[transLength];
for (int i = 0; i < transLength; i++)
{
var item = stateInfo.transtionList[i];
AnimatorTransition item2 = new AnimatorTransition(parameters, item, i);
animatorTransitions[i] = item2;
}
}
private static void CopyTransitionParameters(AnimatorTransition srcTransition, AnimatorTransition dstTransition)
{
dstTransition.hideFlags = srcTransition.hideFlags;
dstTransition.isExit = srcTransition.isExit;
dstTransition.mute = srcTransition.mute;
dstTransition.name = srcTransition.name;
dstTransition.solo = srcTransition.solo;
foreach (var srcCondition in srcTransition.conditions)
{
dstTransition.AddCondition(srcCondition.mode, srcCondition.threshold, srcCondition.parameter);
}
}
public static void ApplyTo(this AnimatorTransition source, AnimatorTransition dest)
{
dest.mute = source.mute;
dest.solo = source.solo;
dest.name = source.name;
dest.hideFlags = source.hideFlags;
foreach (var condition in source.conditions)
{
dest.AddCondition(condition.mode, condition.threshold, condition.parameter);
}
}
private static void ApplyTransitionSettings(AnimatorTransition transition, AnimatorTransition newTransition)
{
newTransition.hideFlags = transition.hideFlags;
newTransition.isExit = transition.isExit;
newTransition.mute = transition.mute;
newTransition.name = transition.name;
newTransition.solo = transition.solo;
foreach (var condition in transition.conditions)
{
newTransition.AddCondition(condition.mode, condition.threshold, condition.parameter);
}
}
private void CreateEntryEdges(AnimatorTransition transition, AnimatorStateMachine owner)
{
UnityEditor.Graphs.AnimationStateMachine.Node dstNode = null;
if (transition.destinationStateMachine != null)
{
dstNode = this.FindNodeForEdges(transition.destinationStateMachine);
}
else
{
dstNode = this.FindNodeForEdges(transition.destinationState);
}
this.CreateEdges(this.m_EntryNode, dstNode, new TransitionEditionContext(transition, null, null, owner));
}
public static void CloneTo(this AnimatorTransition source, AnimatorTransition dest)
{
dest.mute = source.mute;
dest.solo = source.solo;
dest.name = source.name;
dest.hideFlags = source.hideFlags;
foreach (var condition in source.conditions)
{
dest.AddCondition(condition.mode, condition.threshold, condition.parameter);
}
// source.destinationState is ignored because it is resolved by parent
// source.destinationStateMachine is ignored because it is resolved by parent
}
public void AddState(PlayableAnimator playableAnimator, string groupName, int layer)
{
string tstateName = string.IsNullOrEmpty(stateName) ? clip.name : stateName;
PlayableStateController.StateInfo tinfo = playableAnimator.AddState(clip, tstateName, groupName, layer);
tinfo.speed = speed;
if (transtions != null && transtions.Length > 0)
{
AnimatorTransition[] ttransObj = new AnimatorTransition[transtions.Length];
tinfo.transtions = ttransObj;
for (int i = 0; i < ttransObj.Length; i++)
{
ttransObj[i] = new AnimatorTransition(playableAnimator.StateController.Params, transtions[i], i);
}
}
}
private void CopyOrCreateEntryTransition(AnimatorStateMachine outStateMachine, AnimatorTransition refTransition, AnimatorState outState)
{
AnimatorTransition outTransition = FindEntryTransition(outStateMachine, outState);
if (outTransition == null)
{
outTransition = outStateMachine.AddEntryTransition(outState);
}
outTransition.solo = refTransition.solo;
outTransition.mute = refTransition.mute;
outTransition.isExit = refTransition.isExit;
foreach (AnimatorCondition refCondition in refTransition.conditions)
{
RemoveAllAndAddCondition(outTransition, refCondition.parameter, refCondition.mode, refCondition.threshold);
}
}
public PPtr <AnimatorTransition>[] GetEntryTransitions(VirtualSerializedFile file,
AnimatorController controller, uint ID, IReadOnlyList <AnimatorState> states)
{
if (IsReadConstantArray(controller.File.Version))
{
foreach (OffsetPtr <SelectorStateConstant> selectorPtr in SelectorStateConstantArray)
{
SelectorStateConstant selector = selectorPtr.Instance;
if (selector.FullPathID == ID && selector.IsEntry)
{
PPtr <AnimatorTransition>[] transitions = new PPtr <AnimatorTransition> [selector.TransitionConstantArray.Count - 1];
for (int i = 0; i < selector.TransitionConstantArray.Count - 1; i++)
{
SelectorTransitionConstant selectorTrans = selector.TransitionConstantArray[i].Instance;
AnimatorTransition transition = new AnimatorTransition(file, controller, selectorTrans, states);
transitions[i] = PPtr <AnimatorTransition> .CreateVirtualPointer(transition);
}
return(transitions);
}
}
}
return(new PPtr <AnimatorTransition> [0]);
}
public static AnimatorStateMachine CloneMachine(this AnimatorStateMachine machine)
{
AnimatorStateMachine output = new AnimatorStateMachine();
//All Serializable Fields (ex. Primitives)
EditorUtility.CopySerialized(machine, output);
//State Machines
ChildAnimatorStateMachine[] outMachines = new ChildAnimatorStateMachine[machine.stateMachines.Length];
for (int i = 0; i < outMachines.Length; i++)
{
outMachines[i] = new ChildAnimatorStateMachine
{
position = machine.stateMachines[i].position,
stateMachine = CloneMachine(machine.stateMachines[i].stateMachine)
};
}
output.stateMachines = outMachines;
//States
ChildAnimatorState[] outStates = new ChildAnimatorState[machine.states.Length];
for (int i = 0; i < outStates.Length; i++)
{
outStates[i] = new ChildAnimatorState
{
position = machine.states[i].position,
state = CloneState(machine.states[i].state)
};
}
//State Transitions
for (int i = 0; i < outStates.Length; i++)
{
AnimatorStateTransition[] outTransitions = new AnimatorStateTransition[machine.states[i].state.transitions.Length];
for (int j = 0; j < outTransitions.Length; j++)
{
outTransitions[j] = (AnimatorStateTransition)CloneTransition(machine.states[i].state.transitions[j], outStates);
}
outStates[i].state.transitions = outTransitions;
}
output.states = outStates;
//Any Transitions
AnimatorStateTransition[] outAnyTransitions = new AnimatorStateTransition[machine.anyStateTransitions.Length];
for (int i = 0; i < outAnyTransitions.Length; i++)
{
outAnyTransitions[i] = (AnimatorStateTransition)CloneTransition(machine.anyStateTransitions[i], outStates);
}
output.anyStateTransitions = outAnyTransitions;
//Entry Transitions
AnimatorTransition[] outEntryTransitions = new AnimatorTransition[machine.entryTransitions.Length];
for (int i = 0; i < outEntryTransitions.Length; i++)
{
outEntryTransitions[i] = (AnimatorTransition)CloneTransition(machine.entryTransitions[i], outStates);
}
output.entryTransitions = outEntryTransitions;
//Behaviors
StateMachineBehaviour[] outBehaviors = new StateMachineBehaviour[machine.behaviours.Length];
for (int i = 0; i < outBehaviors.Length; i++)
{
outBehaviors[i] = CloneBehavior(machine.behaviours[i]);
}
output.behaviours = outBehaviors;
//Default State
foreach (ChildAnimatorState childState in outStates)
{
if (childState.state.name == machine.defaultState.name)
{
output.defaultState = childState.state;
break;
}
}
return(output);
}
public static UnityEditor.Animations.AnimatorStateTransition AddTransitionEx(this UnityEditor.Animations.AnimatorState target, UnityEditor.Animations.AnimatorState toState, AnimatorTransition transitionConfig)
{
if (
(transitionConfig.ignoreSourceAnimNames != null &&
transitionConfig.ignoreSourceAnimNames.Contains(target.name))
||
(transitionConfig.ignoreSourceAnimTags != null &&
transitionConfig.ignoreSourceAnimTags.Contains(target.tag))
)
{
return(null);
}
if (
(transitionConfig.containSourceAnimNames != null && transitionConfig.containSourceAnimNames.Contains(target.name) == false)
&&
(transitionConfig.ignoreSourceAnimTags != null && transitionConfig.ignoreSourceAnimTags.Contains(target.tag) == false)
)
{
return(null);
}
// if (nameCanTransition && tagCanTransition)
{
var transition = target.AddTransition(toState);
// transition.interruptionSource = UnityEditor.Animations.TransitionInterruptionSource.Destination;
transition.interruptionSource = transitionConfig.interruptionSource;// UnityEditor.Animations.TransitionInterruptionSource.Source;
transition.hasFixedDuration = true;
transition.hasExitTime = transitionConfig.hasExitTime;
transition.exitTime = transitionConfig.exitTime;
transition.duration = transitionConfig.duration;
transition.offset = transitionConfig.offset;
if (transitionConfig.hasFixedDuration == false)
{
if (target.motion is AnimationClip targetClip)
{
transition.exitTime /= targetClip.length;
transition.duration /= targetClip.length;
transition.offset /= targetClip.length;
}
}
// transition.exitTime = 1;
// transition.duration = 0;
// if (transitionConfig.conditions != null)
// {
if (transitionConfig.conditions != null)
{
foreach (var conditionConfig in transitionConfig.conditions)
{
transition.AddCondition(conditionConfig.animatorConditionMode, conditionConfig.threshold, conditionConfig.parameter);
}
}
// }
return(transition);
}
// return null;
}
private static void CloneTransitions(AnimatorStateMachine old, AnimatorStateMachine n)
{
List <AnimatorState> oldStates = GetStatesRecursive(old);
List <AnimatorState> newStates = GetStatesRecursive(n);
List <AnimatorStateMachine> oldStateMachines = GetStateMachinesRecursive(old);
List <AnimatorStateMachine> newStateMachines = GetStateMachinesRecursive(n);
// Generate state transitions
for (int i = 0; i < oldStates.Count; i++)
{
foreach (var transition in oldStates[i].transitions)
{
AnimatorStateTransition newTransition = null;
if (transition.isExit)
{
newTransition = newStates[i].AddExitTransition();
}
else if (transition.destinationState != null)
{
var dstState = FindMatchingState(oldStates, newStates, transition);
if (dstState != null)
{
newTransition = newStates[i].AddTransition(dstState);
}
}
else if (transition.destinationStateMachine != null)
{
var dstState = FindMatchingStateMachine(oldStateMachines, newStateMachines, transition);
if (dstState != null)
{
newTransition = newStates[i].AddTransition(dstState);
}
}
if (newTransition != null)
{
ApplyTransitionSettings(transition, newTransition);
}
}
}
// Generate AnyState transitiosn
foreach (var transition in old.anyStateTransitions)
{
AnimatorStateTransition newTransition = null;
if (transition.destinationState != null)
{
var dstState = FindMatchingState(oldStates, newStates, transition);
if (dstState != null)
{
newTransition = n.AddAnyStateTransition(dstState);
}
}
else if (transition.destinationStateMachine != null)
{
var dstState = FindMatchingStateMachine(oldStateMachines, newStateMachines, transition);
if (dstState != null)
{
newTransition = n.AddAnyStateTransition(dstState);
}
}
if (newTransition != null)
{
ApplyTransitionSettings(transition, newTransition);
}
}
// Generate EntryState transitions
foreach (var transition in old.entryTransitions)
{
AnimatorTransition newTransition = null;
if (transition.destinationState != null)
{
var dstState = FindMatchingState(oldStates, newStates, transition);
if (dstState != null)
{
newTransition = n.AddEntryTransition(dstState);
}
}
else if (transition.destinationStateMachine != null)
{
var dstState = FindMatchingStateMachine(oldStateMachines, newStateMachines, transition);
if (dstState != null)
{
newTransition = n.AddEntryTransition(dstState);
}
}
if (newTransition != null)
{
ApplyTransitionSettings(transition, newTransition);
}
}
}
private void TryInitialize(ProjectAssetContainer container)
{
if (m_initialized)
{
return;
}
AnimatorController asset = (AnimatorController)Asset;
ControllerConstant controller = asset.Controller;
IReadOnlyList <OffsetPtr <StateMachineConstant> > stateMachinesConst = controller.StateMachineArray;
m_stateMachines = new AnimatorStateMachine[stateMachinesConst.Count];
for (int i = 0; i < stateMachinesConst.Count; i++)
{
StateMachineConstant stateMachineConstant = stateMachinesConst[i].Instance;
AnimatorStateMachine stateMachine = new AnimatorStateMachine(container.VirtualFile, asset, i);
m_stateMachines[i] = stateMachine;
}
for (int i = 0; i < StateMachines.Count; i++)
{
AnimatorStateMachine stateMachine = StateMachines[i];
StateMachineConstant stateMachineConstant = asset.Controller.StateMachineArray[i].Instance;
AddAsset(stateMachine);
foreach (PPtr <AnimatorStateTransition> transitionPtr in stateMachine.AnyStateTransitions)
{
AnimatorStateTransition transition = transitionPtr.GetAsset(container.VirtualFile);
AddAsset(transition);
}
foreach (PPtr <AnimatorTransition> transitionPtr in stateMachine.EntryTransitions)
{
AnimatorTransition transition = transitionPtr.GetAsset(container.VirtualFile);
AddAsset(transition);
}
for (int j = 0; j < stateMachine.ChildStates.Count; j++)
{
PPtr <AnimatorState> statePtr = stateMachine.ChildStates[j].State;
AnimatorState state = statePtr.GetAsset(container.VirtualFile);
StateConstant stateConstant = stateMachineConstant.StateConstantArray[j].Instance;
AddAsset(state);
if (state.Motion.IsVirtual)
{
AddBlendTree(container.VirtualFile, state.Motion.CastTo <BlendTree>());
}
for (int k = 0; k < state.Transitions.Count; k++)
{
PPtr <AnimatorStateTransition> transitionPtr = state.Transitions[k];
AnimatorStateTransition transition = transitionPtr.GetAsset(container.VirtualFile);
TransitionConstant transitionConstant = stateConstant.TransitionConstantArray[k].Instance;
AddAsset(transition);
}
}
}
m_initialized = true;
}
public void clear()
{
m_condList.Clear();
m_animatorTransition = null;
}
/// <summary>
/// Checks if Transition is existing in list of states.
/// Transitions define when and how the state machine switch from on state to another.
/// AnimatorTransition always originate from a StateMachine or a StateMachine entry. They do not define timing parameters.
/// </summary>
/// <returns><c>true</c>, if exists was animatorstated, <c>false</c> otherwise.</returns>
/// <param name="condition">Keyword.</param>
/// <param name="transitions">Transitions.</param>
/// <param name="transition">Animator state.</param>
protected bool TransitionExists(string condition, AnimatorTransition[] transitions, out AnimatorTransition transition)
{
for (int i = 0; i < transitions.Length; i++)
{
if (transitions[i].conditions[0].parameter == condition)
{
transition = transitions[i];
return(true);
}
}
transition = null;
return(false);
}
private static void CloneTransitions(AnimatorStateMachine old, AnimatorStateMachine n)
{
AnimatorState[] oldStates = old.states.Select(x => x.state).ToArray();
AnimatorState[] newStates = n.states.Select(x => x.state).ToArray();
AnimatorStateMachine[] oldStateMachines = old.stateMachines.Select(x => x.stateMachine).ToArray();
AnimatorStateMachine[] newStateMachines = n.stateMachines.Select(x => x.stateMachine).ToArray();
// Generate state transitions
for (int i = 0; i < oldStates.Length; i++)
{
foreach (var transition in oldStates[i].transitions)
{
AnimatorStateTransition newTransition = null;
if (transition.isExit)
{
newTransition = newStates[i].AddExitTransition();
}
else if (transition.destinationState != null)
{
var dstState = Array.Find(newStates, x => x.name == transition.destinationState.name);
if (dstState != null)
{
newTransition = newStates[i].AddTransition(dstState);
}
}
else if (transition.destinationStateMachine != null)
{
var dstState = Array.Find(newStateMachines, x => x.name == transition.destinationStateMachine.name);
if (dstState != null)
{
newTransition = newStates[i].AddTransition(dstState);
}
}
if (newTransition != null)
{
ApplyTransitionSettings(transition, newTransition);
}
}
}
// Generate AnyState transitiosn
foreach (var transition in old.anyStateTransitions)
{
AnimatorStateTransition newTransition = null;
if (transition.destinationState != null)
{
var dstState = Array.Find(newStates, x => x.name == transition.destinationState.name);
if (dstState != null)
{
newTransition = n.AddAnyStateTransition(dstState);
}
}
else if (transition.destinationStateMachine != null)
{
var dstState = Array.Find(newStateMachines, x => x.name == transition.destinationStateMachine.name);
if (dstState != null)
{
newTransition = n.AddAnyStateTransition(dstState);
}
}
if (newTransition != null)
{
ApplyTransitionSettings(transition, newTransition);
}
}
// Generate EntryState transitiosn
foreach (var transition in old.entryTransitions)
{
AnimatorTransition newTransition = null;
if (transition.destinationState != null)
{
var dstState = Array.Find(newStates, x => x.name == transition.destinationState.name);
if (dstState != null)
{
newTransition = n.AddEntryTransition(dstState);
}
}
else if (transition.destinationStateMachine != null)
{
var dstState = Array.Find(newStateMachines, x => x.name == transition.destinationStateMachine.name);
if (dstState != null)
{
newTransition = n.AddEntryTransition(dstState);
}
}
if (newTransition != null)
{
ApplyTransitionSettings(transition, newTransition);
}
}
for (int i = 0; i < oldStateMachines.Length; i++)
{
CloneTransitions(oldStateMachines[i], newStateMachines[i]);
}
}
public static AnimatorStateMachine CloneDeep(this AnimatorStateMachine source)
{
var dest = new AnimatorStateMachine
{
defaultState = InstanceCaches <AnimatorState> .FindOrCreate(source.defaultState, w => w.CloneDeep()),
anyStatePosition = source.anyStatePosition,
entryPosition = source.entryPosition,
exitPosition = source.exitPosition,
parentStateMachinePosition = source.parentStateMachinePosition,
hideFlags = source.hideFlags,
name = source.name
};
foreach (var sourceState in source.states)
{
dest.AddState(InstanceCaches <AnimatorState> .FindOrCreate(sourceState.state, w => w.CloneDeep()), sourceState.position);
}
foreach (var sourceTransition in source.anyStateTransitions)
{
AnimatorStateTransition transition = null;
if (sourceTransition.destinationStateMachine != null)
{
transition = dest.AddAnyStateTransition(InstanceCaches <AnimatorStateMachine> .FindOrCreate(sourceTransition.destinationStateMachine, CloneDeep));
}
if (sourceTransition.destinationState != null)
{
transition = dest.AddAnyStateTransition(InstanceCaches <AnimatorState> .FindOrCreate(sourceTransition.destinationState, w => w.CloneDeep()));
}
if (transition == null)
{
throw new ArgumentNullException(nameof(transition));
}
sourceTransition.CloneTo(transition);
// should always false
if (InstanceCaches <AnimatorStateTransition> .Find(sourceTransition.GetInstanceID()) == null)
{
InstanceCaches <AnimatorStateTransition> .Register(sourceTransition.GetInstanceID(), transition);
}
}
foreach (var sourceTransition in source.entryTransitions)
{
AnimatorTransition transition = null;
if (sourceTransition.destinationStateMachine != null)
{
transition = dest.AddEntryTransition(InstanceCaches <AnimatorStateMachine> .FindOrCreate(sourceTransition.destinationStateMachine, CloneDeep));
}
if (sourceTransition.destinationState != null)
{
transition = dest.AddEntryTransition(InstanceCaches <AnimatorState> .FindOrCreate(sourceTransition.destinationState, w => w.CloneDeep()));
}
if (transition == null)
{
throw new ArgumentNullException(nameof(transition));
}
transition.CloneTo(sourceTransition);
// should always false
if (InstanceCaches <AnimatorTransition> .Find(sourceTransition.GetInstanceID()) == null)
{
InstanceCaches <AnimatorTransition> .Register(sourceTransition.GetInstanceID(), transition);
}
}
foreach (var sourceBehaviour in source.behaviours)
{
var behaviour = dest.AddStateMachineBehaviour(sourceBehaviour.GetType());
sourceBehaviour.CloneDeepTo(behaviour);
// store
InstanceCaches <StateMachineBehaviour> .Register(behaviour.GetInstanceID(), behaviour);
}
foreach (var sourceStateMachine in source.stateMachines)
{
dest.AddStateMachine(InstanceCaches <AnimatorStateMachine> .FindOrCreate(sourceStateMachine.stateMachine, CloneDeep), sourceStateMachine.position);
}
return(dest);
}
private void GetTransitionContexts()
{
this.m_Transitions = new List <TransitionEditionContext>();
switch (this.m_Type)
{
case TransitionType.eState:
{
if (this.m_State == null)
{
return;
}
AnimatorStateTransition[] transitions = this.m_State.transitions;
AnimatorStateTransition[] array = transitions;
for (int i = 0; i < array.Length; i++)
{
AnimatorStateTransition aTransition = array[i];
this.m_Transitions.Add(new TransitionEditionContext(aTransition, this.m_State, null, null));
}
break;
}
case TransitionType.eAnyState:
if (this.m_ActiveStateMachine)
{
AnimatorStateTransition[] anyStateTransitions = this.m_ActiveStateMachine.anyStateTransitions;
AnimatorStateTransition[] array2 = anyStateTransitions;
for (int j = 0; j < array2.Length; j++)
{
AnimatorStateTransition aTransition2 = array2[j];
this.m_Transitions.Add(new TransitionEditionContext(aTransition2, null, null, this.m_ActiveStateMachine));
}
}
break;
case TransitionType.eStateMachine:
if (this.m_ActiveStateMachine)
{
AnimatorTransition[] stateMachineTransitions = this.m_ActiveStateMachine.GetStateMachineTransitions(this.m_StateMachine);
AnimatorTransition[] array3 = stateMachineTransitions;
for (int k = 0; k < array3.Length; k++)
{
AnimatorTransition aTransition3 = array3[k];
this.m_Transitions.Add(new TransitionEditionContext(aTransition3, null, this.m_StateMachine, this.m_ActiveStateMachine));
}
}
break;
case TransitionType.eEntry:
{
if (this.m_StateMachine == null)
{
return;
}
AnimatorTransition[] entryTransitions = this.m_StateMachine.entryTransitions;
AnimatorTransition[] array4 = entryTransitions;
for (int l = 0; l < array4.Length; l++)
{
AnimatorTransition aTransition4 = array4[l];
this.m_Transitions.Add(new TransitionEditionContext(aTransition4, null, null, this.m_StateMachine));
}
break;
}
}
}
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();
}
static void CreateController()
{
// Creates the controller
AnimatorController controller = AnimatorController.CreateAnimatorControllerAtPath("Assets/Animations/Motion.controller");
// Add Animation Clips
AnimationClip clip = new AnimationClip();
clip.frameRate = 24;
AssetDatabase.CreateAsset(clip, "Assets/Animations/Motion.anim");
AssetDatabase.SaveAssets();
// Add parameters
controller.AddParameter("TransitionNow", AnimatorControllerParameterType.Trigger);
controller.AddParameter("Reset", AnimatorControllerParameterType.Trigger);
controller.AddParameter("GotoB1", AnimatorControllerParameterType.Trigger);
controller.AddParameter("GotoC", AnimatorControllerParameterType.Trigger);
// Add StateMachines
AnimatorStateMachine rootStateMachine = controller.layers[0].stateMachine;
AnimatorStateMachine stateMachineA = rootStateMachine.AddStateMachine("smA");
AnimatorStateMachine stateMachineB = rootStateMachine.AddStateMachine("smB");
AnimatorStateMachine stateMachineC = stateMachineB.AddStateMachine("smC");
// Add Clip
// Add States
AnimatorState stateA1 = stateMachineA.AddState("stateA1");
AnimatorState stateB1 = stateMachineB.AddState("stateB1");
AnimatorState stateB2 = stateMachineB.AddState("stateB2");
stateMachineC.AddState("stateC1");
AnimatorState stateC2 = stateMachineC.AddState("stateC2"); // don’t add an entry transition, should entry to state by default
// Add clip
stateA1.motion = clip;
// Add Transitions
AnimatorStateTransition exitTransition = stateA1.AddExitTransition();
exitTransition.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "TransitionNow");
exitTransition.duration = 0;
AnimatorStateTransition resetTransition = rootStateMachine.AddAnyStateTransition(stateA1);
resetTransition.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "Reset");
resetTransition.duration = 0;
AnimatorTransition transitionB1 = stateMachineB.AddEntryTransition(stateB1);
transitionB1.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "GotoB1");
stateMachineB.AddEntryTransition(stateB2);
stateMachineC.defaultState = stateC2;
AnimatorStateTransition exitTransitionC2 = stateC2.AddExitTransition();
exitTransitionC2.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "TransitionNow");
exitTransitionC2.duration = 0;
AnimatorTransition stateMachineTransition = rootStateMachine.AddStateMachineTransition(stateMachineA, stateMachineC);
stateMachineTransition.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "GotoC");
rootStateMachine.AddStateMachineTransition(stateMachineA, stateMachineB);
}
