public static AnimatorStateTransition GetTransitionTo(FPlayAnimationEvent animEvt)
{
FAnimationTrack animTrack = (FAnimationTrack)animEvt.Track;
if (animTrack.AnimatorController == null)
{
return(null);
}
AnimatorController controller = (AnimatorController)animTrack.AnimatorController;
AnimatorState animState = null;
AnimatorControllerLayer layer = FindLayer(controller, ((FAnimationTrack)animEvt.Track).LayerName);
if (layer == null)
{
return(null);
}
if (layer.stateMachine.stateMachines.Length == 0)
{
return(null);
}
ChildAnimatorStateMachine fluxSM = layer.stateMachine.stateMachines[0];
AnimatorStateMachine stateMachine = fluxSM.stateMachine;
for (int i = 0; i != stateMachine.states.Length; ++i)
{
if (stateMachine.states[i].state.nameHash == animEvt._stateHash)
{
animState = stateMachine.states[i].state;
break;
}
}
if (animState == null)
{
// Debug.LogError("Couldn't find state " + animEvt._animationClip );
return(null);
}
for (int i = 0; i != stateMachine.states.Length; ++i)
{
AnimatorState state = stateMachine.states[i].state;
AnimatorStateTransition[] transitions = state.transitions;
for (int j = 0; j != transitions.Length; ++j)
{
if (transitions[j].destinationState == animState)
{
return(transitions[j]);
}
}
}
return(null);
}
/// <summary>
/// Generates the code to recreate the motions within the specified state machine.
/// </summary>
/// <param name="childStateMachine">The state machine used to search for motions.</param>
/// <param name="motionSet">The list of motions which have been already generated.</param>
/// <param name="generatedCode">The final generated code.</param>
private static void GenerateMotions(ChildAnimatorStateMachine childStateMachine, HashSet <UnityEngine.Motion> motionSet, StringBuilder generatedCode)
{
var stateMachine = childStateMachine.stateMachine;
if (stateMachine.states.Length > 0)
{
for (int i = 0; i < stateMachine.states.Length; ++i)
{
var motion = stateMachine.states[i].state.motion;
if (motion is BlendTree)
{
// Blend trees can contain other blend trees so recursion is necessary.
GenerateBlendTreeMotions(motion as BlendTree, motionSet, generatedCode);
}
else
{
if (motion != null)
{
GenerateMotion(motion, motionSet, generatedCode);
}
}
}
}
// Search deeper for any motions.
for (int i = 0; i < stateMachine.stateMachines.Length; ++i)
{
GenerateMotions(stateMachine.stateMachines[i], motionSet, generatedCode);
}
}
public Node FindNode(AnimatorStateMachine stateMachine)
{
if (stateMachine == null)
{
return(null);
}
if (stateMachine == this.activeStateMachine)
{
return(null);
}
if (this.m_StateMachineNodeLookup.ContainsKey(stateMachine))
{
return(this.m_StateMachineNodeLookup[stateMachine]);
}
ChildAnimatorStateMachine[] stateMachines = this.activeStateMachine.stateMachines;
for (int i = 0; i < stateMachines.Length; i++)
{
ChildAnimatorStateMachine childAnimatorStateMachine = stateMachines[i];
if (this.HasStateMachine(childAnimatorStateMachine.stateMachine, stateMachine, true))
{
return(this.m_StateMachineNodeLookup[childAnimatorStateMachine.stateMachine]);
}
}
if (this.parentStateMachine)
{
return(this.m_StateMachineNodeLookup[this.parentStateMachine]);
}
return(null);
}
private static void GenerateStateMachineStateTransitions(ChildAnimatorStateMachine childStateMachine, StringBuilder generatedCode)
{
var stateMachine = childStateMachine.stateMachine;
// Add all of the state transitions.
if (stateMachine.states.Length > 0)
{
generatedCode.AppendLine("\t\t\t// State Transitions.");
for (int i = 0; i < stateMachine.states.Length; ++i)
{
var state = stateMachine.states[i].state;
var uniqueStateName = UniqueName(stateMachine.states[i].state);
for (int j = 0; j < state.transitions.Length; ++j)
{
GenerateTransition(uniqueStateName, state.transitions[j], true, false, generatedCode);
generatedCode.AppendLine();
}
}
}
// Add all of the state machines.
for (int i = 0; i < stateMachine.stateMachines.Length; ++i)
{
GenerateStateMachineStateTransitions(stateMachine.stateMachines[i], generatedCode);
}
}
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);
}
/// <summary>
/// TODO: 子ステートマシンをディープコピーして欲しい。
/// </summary>
public static ChildAnimatorStateMachine DeepcopyChildStatemachine(ChildAnimatorStateMachine old)
{
ChildAnimatorStateMachine n = new ChildAnimatorStateMachine();
n.position = old.position;
n.stateMachine = AconDeepcopy.DeepcopyStatemachine(old.stateMachine);
return(n);
}
private static ChildAnimatorStateMachine CloneChildStateMachine(ChildAnimatorStateMachine old)
{
var n = new ChildAnimatorStateMachine
{
position = old.position,
stateMachine = CloneStateMachine(old.stateMachine)
};
return(n);
}
private void CreateNodeFromStateMachine(ChildAnimatorStateMachine subStateMachine)
{
StateMachineNode stateMachineNode = this.CreateAndAddNode <StateMachineNode>(string.Empty, subStateMachine.position);
stateMachineNode.stateMachine = subStateMachine.stateMachine;
stateMachineNode.style = "node hex";
if (this.rootStateMachine.defaultState && this.HasState(subStateMachine.stateMachine, this.rootStateMachine.defaultState, true))
{
stateMachineNode.color = Styles.Color.Orange;
}
this.m_StateMachineNodeLookup.Add(subStateMachine.stateMachine, stateMachineNode);
}
/// <summary>
/// TODO: 子ステートマシンをディープコピーして欲しい。
/// </summary>
public static ChildAnimatorStateMachine[] DeepcopyChildStatemachine(ChildAnimatorStateMachine[] oldItems)
{
ChildAnimatorStateMachine[] nItems = new ChildAnimatorStateMachine[oldItems.Length];
int i = 0;
foreach (ChildAnimatorStateMachine old in oldItems)
{
nItems[i] = DeepcopyChildStatemachine(old);
i++;
}
return(nItems);
}
private void CreateNodeFromStateMachine(ChildAnimatorStateMachine subStateMachine)
{
StateMachineNode node = this.CreateAndAddNode <StateMachineNode>("", subStateMachine.position);
node.stateMachine = subStateMachine.stateMachine;
node.style = "node hex";
if ((this.rootStateMachine.defaultState != null) && this.HasState(subStateMachine.stateMachine, this.rootStateMachine.defaultState, true))
{
node.color = UnityEditor.Graphs.Styles.Color.Orange;
}
this.m_StateMachineNodeLookup.Add(subStateMachine.stateMachine, node);
}
private void CreateEdges()
{
this.m_ConnectedSlotsCache.Clear();
List <ChildAnimatorState> statesRecursive = this.rootStateMachine.statesRecursive;
foreach (ChildAnimatorState state in statesRecursive)
{
AnimatorState sourceState = state.state;
AnimatorStateTransition[] transitions = sourceState.transitions;
foreach (AnimatorStateTransition transition in transitions)
{
if (transition != null)
{
this.CreateStateEdges(sourceState, transition);
}
}
}
AnimatorStateTransition[] anyStateTransitions = this.rootStateMachine.anyStateTransitions;
foreach (AnimatorStateTransition transition2 in anyStateTransitions)
{
if (transition2 != null)
{
this.CreateAnyStateEdges(transition2);
}
}
List <ChildAnimatorStateMachine> stateMachinesRecursive = this.rootStateMachine.stateMachinesRecursive;
ChildAnimatorStateMachine item = new ChildAnimatorStateMachine {
stateMachine = this.rootStateMachine
};
stateMachinesRecursive.Add(item);
foreach (ChildAnimatorStateMachine machine2 in stateMachinesRecursive)
{
ChildAnimatorStateMachine[] stateMachines = machine2.stateMachine.stateMachines;
foreach (ChildAnimatorStateMachine machine3 in stateMachines)
{
AnimatorTransition[] stateMachineTransitions = machine2.stateMachine.GetStateMachineTransitions(machine3.stateMachine);
foreach (AnimatorTransition transition3 in stateMachineTransitions)
{
this.CreateSelectorEdges(transition3, machine2.stateMachine, machine3.stateMachine);
}
}
}
AnimatorTransition[] entryTransitions = this.activeStateMachine.entryTransitions;
foreach (AnimatorTransition transition4 in entryTransitions)
{
this.CreateEntryEdges(transition4, this.activeStateMachine);
}
this.CreateDefaultStateEdge(this.activeStateMachine.defaultState, this.activeStateMachine);
}
private void FillStateMachineLookupFromStateMachine(AnimatorStateMachine stateMachine)
{
ChildAnimatorStateMachine[] stateMachines = stateMachine.stateMachines;
for (int i = 0; i < stateMachines.Length; i++)
{
ChildAnimatorStateMachine childAnimatorStateMachine = stateMachines[i];
this.FillStateMachineLookupFromStateMachine(childAnimatorStateMachine.stateMachine);
this.m_StateMachineLookup.Add(childAnimatorStateMachine.stateMachine, stateMachine);
}
ChildAnimatorState[] states = stateMachine.states;
for (int j = 0; j < states.Length; j++)
{
ChildAnimatorState childAnimatorState = states[j];
this.m_StateMachineProxyLookup.Add(childAnimatorState.state, stateMachine);
}
}
public static void GenericMenuForStateMachineNode(StateMachineNode toStateMachineNode, bool showStateMachine, GenericMenu.MenuFunction2 func)
{
AnimatorStateMachine parentStateMachine = null;
List <ChildAnimatorState> stateList = new List <ChildAnimatorState>();
List <ChildAnimatorStateMachine> stateMachineList = new List <ChildAnimatorStateMachine>();
PopulateSubNodeList(toStateMachineNode, ref stateList, ref stateMachineList, ref parentStateMachine);
if ((stateList.Count == 0) && (stateMachineList.Count == 1))
{
ChildAnimatorStateMachine machine2 = stateMachineList[0];
func(machine2.stateMachine);
}
else
{
GenericMenu menu = new GenericMenu();
foreach (ChildAnimatorState state in stateList)
{
private AnimatorStateMachine AddStateMachine(StateMachine stateMachine)
{
AnimatorStateMachine controllerStateMachine;
if (stateMachine.overrideExistingStateMachine)
{
List <ChildAnimatorState> newStates = new List <ChildAnimatorState>();
List <ChildAnimatorStateMachine> newStateMachines = new List <ChildAnimatorStateMachine>();
controllerStateMachine = stateMachine.controllerStateMachine != null
? stateMachine.controllerStateMachine
: new AnimatorStateMachine();
stateMachine.controllerStateMachine = controllerStateMachine;
controllerStateMachine.name = stateMachine.Name;
foreach (var state in stateMachine.states)
{
switch (state.type)
{
case StateType.State: {
var temp = new ChildAnimatorState();
temp.state = new UnityEditor.Animations.AnimatorState();
temp.state.motion = state.state.motion;
temp.state.name = state.state.Name;
newStates.Add(temp);
break;
}
case StateType.StateMachine:
default: {
var temp = new ChildAnimatorStateMachine();
temp.stateMachine = AddStateMachine(state.stateMachine);
newStateMachines.Add(temp);
break;
}
}
}
controllerStateMachine.stateMachines = newStateMachines.ToArray();
controllerStateMachine.states = newStates.ToArray();
}
else
{
controllerStateMachine = stateMachine.controllerStateMachine;
}
return(controllerStateMachine);
}
/// <summary>
/// Collects all fields that will be serialized.
/// </summary>
/// <param name="obj"></param>
/// <param name="info"></param>
/// <param name="context"></param>
public override void GetObjectData(object obj, SerializationInfo info, StreamingContext context)
{
if (obj == null)
{
return;
}
if (obj is ChildAnimatorStateMachine)
{
ChildAnimatorStateMachine fsm = (ChildAnimatorStateMachine)obj;
info.AddValue("position", (object)fsm.position);
info.AddValue("stateMachine", (object)fsm.stateMachine);
}
else if (obj is ChildAnimatorState)
{
ChildAnimatorState state = (ChildAnimatorState)obj;
info.AddValue("position", (object)state.position);
info.AddValue("state", (object)state.state);
}
}
private static void PopulateSubNodeList(StateMachineNode toStateMachineNode, ref List <ChildAnimatorState> stateList, ref List <ChildAnimatorStateMachine> stateMachineList, ref AnimatorStateMachine parentStateMachine)
{
if (toStateMachineNode.stateMachine == AnimatorControllerTool.tool.stateMachineGraph.parentStateMachine)
{
stateList = AnimatorControllerTool.tool.stateMachineGraph.rootStateMachine.statesRecursive;
stateList.RemoveAll((ChildAnimatorState s) => AnimatorControllerTool.tool.stateMachineGraph.activeStateMachine.HasState(s.state));
stateMachineList = AnimatorControllerTool.tool.stateMachineGraph.rootStateMachine.stateMachinesRecursive;
stateMachineList.RemoveAll((ChildAnimatorStateMachine s) => AnimatorControllerTool.tool.stateMachineGraph.activeStateMachine.HasStateMachine(s.stateMachine) || AnimatorControllerTool.tool.stateMachineGraph.activeStateMachine == s.stateMachine);
parentStateMachine = AnimatorControllerTool.tool.stateMachineGraph.rootStateMachine;
}
else
{
parentStateMachine = toStateMachineNode.stateMachine;
stateList = toStateMachineNode.stateMachine.statesRecursive;
stateMachineList = parentStateMachine.stateMachinesRecursive;
}
ChildAnimatorStateMachine item = default(ChildAnimatorStateMachine);
item.stateMachine = parentStateMachine;
stateMachineList.Add(item);
}
private void CreateNodes()
{
this.m_StateNodeLookup.Clear();
this.m_StateMachineNodeLookup.Clear();
ChildAnimatorState[] states = this.activeStateMachine.states;
for (int i = 0; i < states.Length; i++)
{
ChildAnimatorState state = states[i];
this.CreateNodeFromState(state);
}
ChildAnimatorStateMachine[] stateMachines = this.activeStateMachine.stateMachines;
for (int j = 0; j < stateMachines.Length; j++)
{
ChildAnimatorStateMachine subStateMachine = stateMachines[j];
this.CreateNodeFromStateMachine(subStateMachine);
}
this.CreateAnyStateNode();
this.CreateEntryExitNodes();
if (this.parentStateMachine)
{
this.CreateParentStateMachineNode();
}
}
private static IEnumerable <ChildAnimatorState> AllChildStates(ChildAnimatorStateMachine casm)
{
return(casm.stateMachine.states.Concat(casm.stateMachine.stateMachines.SelectMany(AllChildStates)));
}
/// <summary>
/// Register all the state machines
/// </summary>
/// <param name="stateMachine"></param>
/// <param name="parentState"></param>
private void RegisterAnimatorStates(AnimatorStateMachine stateMachine, string parentState)
{
if (m_stateNameHash == null)
{
m_stateNameHash = new Dictionary <string, int>();
}
if (m_stateHashName == null)
{
m_stateHashName = new Dictionary <int, string>();
}
foreach (ChildAnimatorState childState in stateMachine.states) //for each state
{
string stateName = childState.state.name;
string fullPathName = parentState + "." + stateName;
int shortNameHash = Animator.StringToHash(stateName);
int fullPathHash = Animator.StringToHash(fullPathName);
// Fullpath hash
if (m_stateNameHash.ContainsKey(fullPathName))
{
m_stateNameHash[fullPathName] = fullPathHash;
}
else
{
m_stateNameHash.Add(fullPathName, fullPathHash);
}
// Shortpath hash
if (m_stateNameHash.ContainsKey(stateName))
{
m_stateNameHash[stateName] = shortNameHash;
}
else
{
m_stateNameHash.Add(stateName, shortNameHash);
}
// Fullpath name
if (m_stateHashName.ContainsKey(fullPathHash))
{
m_stateHashName[fullPathHash] = fullPathName;
}
else
{
m_stateHashName.Add(fullPathHash, fullPathName);
}
// Shortpath name
if (m_stateHashName.ContainsKey(shortNameHash))
{
m_stateHashName[shortNameHash] = stateName;
}
else
{
m_stateHashName.Add(shortNameHash, stateName);
}
m_stateCount++;
}
//foreach (ChildAnimatorStateMachine sm in stateMachine.stateMachines) //for each state
//{
// string path = parentState + "." + sm.stateMachine.name;
// RegisterAnimatorStates(sm.stateMachine, path);
//}
for (int i = 0; i < stateMachine.stateMachines.Length; i++)
{
ChildAnimatorStateMachine sm = stateMachine.stateMachines[i];
string path = parentState + "." + sm.stateMachine.name;
RegisterAnimatorStates(sm.stateMachine, path);
}
}
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);
}
private AnimatorStateMachine(AssetInfo assetInfo, AnimatorController controller, int stateMachineIndex) :
base(assetInfo, HideFlags.HideInHierarchy)
{
VirtualSerializedFile virtualFile = (VirtualSerializedFile)assetInfo.File;
LayerConstant layer = controller.Controller.GetLayerByStateMachineIndex(stateMachineIndex);
Name = controller.TOS[layer.Binding];
StateMachineConstant stateMachine = controller.Controller.StateMachineArray[stateMachineIndex].Instance;
int stateCount = stateMachine.StateConstantArray.Count;
int stateMachineCount = 0;
int count = stateCount + stateMachineCount;
int side = (int)Math.Ceiling(Math.Sqrt(count));
List <AnimatorState> states = new List <AnimatorState>();
m_childStates = new ChildAnimatorState[stateCount];
for (int y = 0, stateIndex = 0; y < side && stateIndex < stateCount; y++)
{
for (int x = 0; x < side && stateIndex < stateCount; x++, stateIndex++)
{
Vector3f position = new Vector3f(x * StateOffset, y * StateOffset, 0.0f);
AnimatorState state = AnimatorState.CreateVirtualInstance(virtualFile, controller, stateMachineIndex, stateIndex, position);
ChildAnimatorState childState = new ChildAnimatorState(state, position);
m_childStates[stateIndex] = childState;
states.Add(state);
}
}
#warning TODO: child StateMachines
m_childStateMachines = new ChildAnimatorStateMachine[stateMachineCount];
// set destination state for transitions here because all states has become valid only now
for (int i = 0; i < stateMachine.StateConstantArray.Count; i++)
{
AnimatorState state = states[i];
StateConstant stateConstant = stateMachine.StateConstantArray[i].Instance;
PPtr <AnimatorStateTransition>[] transitions = new PPtr <AnimatorStateTransition> [stateConstant.TransitionConstantArray.Count];
for (int j = 0; j < stateConstant.TransitionConstantArray.Count; j++)
{
TransitionConstant transitionConstant = stateConstant.TransitionConstantArray[j].Instance;
AnimatorStateTransition.Parameters parameters = new AnimatorStateTransition.Parameters
{
StateMachine = stateMachine,
States = states,
TOS = controller.TOS,
Transition = transitionConstant,
Version = controller.File.Version,
};
AnimatorStateTransition transition = AnimatorStateTransition.CreateVirtualInstance(virtualFile, parameters);
transitions[j] = transition.File.CreatePPtr(transition);
}
state.Transitions = transitions;
}
m_anyStateTransitions = new PPtr <AnimatorStateTransition> [stateMachine.AnyStateTransitionConstantArray.Count];
for (int i = 0; i < stateMachine.AnyStateTransitionConstantArray.Count; i++)
{
TransitionConstant transitionConstant = stateMachine.AnyStateTransitionConstantArray[i].Instance;
AnimatorStateTransition.Parameters parameters = new AnimatorStateTransition.Parameters
{
StateMachine = stateMachine,
States = states,
TOS = controller.TOS,
Transition = transitionConstant,
Version = controller.File.Version,
};
AnimatorStateTransition transition = AnimatorStateTransition.CreateVirtualInstance(virtualFile, parameters);
m_anyStateTransitions[i] = transition.File.CreatePPtr(transition);
}
StateMachineConstant.Parameters stateParameters = new StateMachineConstant.Parameters
{
ID = layer.Binding,
States = states,
TOS = controller.TOS,
Version = controller.File.Version,
};
m_entryTransitions = stateMachine.CreateEntryTransitions(virtualFile, stateParameters);
m_stateMachineBehaviours = Array.Empty <PPtr <MonoBehaviour> >();
AnyStatePosition = new Vector3f(0.0f, -StateOffset, 0.0f);
EntryPosition = new Vector3f(StateOffset, -StateOffset, 0.0f);
ExitPosition = new Vector3f(2.0f * StateOffset, -StateOffset, 0.0f);
ParentStateMachinePosition = new Vector3f(0.0f, -2.0f * StateOffset, 0.0f);
DefaultState = ChildStates.Count > 0 ? ChildStates[stateMachine.DefaultState].State : default;
}
/// <summary>
/// Generates the code to recreate the specified state machine.
/// </summary>
/// <param name="parentStateMachineName">The name of the parent state machine variable.</param>
/// <param name="childStateMachine">The state machine to generate the code of.</param>
/// <param name="generatedCode">The final generated code.</param>
private static void GenerateStateMachine(string parentStateMachineName, ChildAnimatorStateMachine childStateMachine, StringBuilder generatedCode)
{
var stateMachine = childStateMachine.stateMachine;
generatedCode.AppendLine("\t\t\t// State Machine.");
var uniqueStateMachineName = UniqueName(stateMachine);
generatedCode.AppendLine("\t\t\tvar " + uniqueStateMachineName + " = " + parentStateMachineName + ".AddStateMachine(\"" +
stateMachine.name + "\", " + Vector3String(childStateMachine.position) + ");");
generatedCode.AppendLine();
// Add all the states.
if (stateMachine.states.Length > 0)
{
generatedCode.AppendLine("\t\t\t// States.");
for (int i = 0; i < stateMachine.states.Length; ++i)
{
var state = stateMachine.states[i].state;
var uniqueStateName = UniqueName(state);
generatedCode.AppendLine("\t\t\tvar " + uniqueStateName + " = " + uniqueStateMachineName + ".AddState(\"" + state.name + "\", " +
Vector3String(stateMachine.states[i].position) + ");");
if (state.motion is BlendTree)
{
var blendTree = state.motion as BlendTree;
var blendTreeName = uniqueStateName + UniqueName(blendTree);
GenerateBlendTree(blendTreeName, blendTree, generatedCode, 3);
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".motion = " + blendTreeName + ";");
}
else if (state.motion != null)
{
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".motion = " + UniqueName(state.motion) + ";");
}
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".cycleOffset = " + state.cycleOffset + "f;");
if (!string.IsNullOrEmpty(state.cycleOffsetParameter))
{
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".cycleOffsetParameter = \"" + state.cycleOffsetParameter + "\";");
}
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".cycleOffsetParameterActive = " + BoolString(state.cycleOffsetParameterActive) + ";");
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".iKOnFeet = " + BoolString(state.iKOnFeet) + ";");
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".mirror = " + BoolString(state.mirror) + ";");
if (!string.IsNullOrEmpty(state.mirrorParameter))
{
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".mirrorParameter = \"" + state.mirrorParameter + "\";");
}
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".mirrorParameterActive = " + BoolString(state.mirrorParameterActive) + ";");
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".speed = " + state.speed + "f;");
if (!string.IsNullOrEmpty(state.speedParameter))
{
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".speedParameter = \"" + state.speedParameter + "\";");
}
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".speedParameterActive = " + BoolString(state.speedParameterActive) + ";");
if (!string.IsNullOrEmpty(state.tag))
{
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".tag = \"" + state.tag + "\";");
}
generatedCode.AppendLine("\t\t\t" + uniqueStateName + ".writeDefaultValues = " + BoolString(state.writeDefaultValues) + ";");
generatedCode.AppendLine();
}
}
// Add all of the any state transitions.
if (stateMachine.anyStateTransitions.Length > 0)
{
generatedCode.AppendLine("\t\t\t// Any State Transitions.");
for (int i = 0; i < stateMachine.anyStateTransitions.Length; ++i)
{
GenerateTransition(uniqueStateMachineName, stateMachine.anyStateTransitions[i], false, true, generatedCode);
generatedCode.AppendLine();
}
}
// Add all of the entry transitions.
if (stateMachine.entryTransitions.Length > 0)
{
generatedCode.AppendLine("\t\t\t// Entry Transitions.");
for (int i = 0; i < stateMachine.entryTransitions.Length; ++i)
{
GenerateTransition(uniqueStateMachineName, stateMachine.entryTransitions[i], false, false, generatedCode);
generatedCode.AppendLine();
}
}
// Add all of the state machines.
for (int i = 0; i < stateMachine.stateMachines.Length; ++i)
{
GenerateStateMachine(uniqueStateMachineName, stateMachine.stateMachines[i], generatedCode);
}
// Add the state machine defaults.
generatedCode.AppendLine("\t\t\t// State Machine Defaults.");
generatedCode.AppendLine("\t\t\t" + uniqueStateMachineName + ".anyStatePosition = " + Vector3String(stateMachine.anyStatePosition) + ";");
generatedCode.AppendLine("\t\t\t" + uniqueStateMachineName + ".defaultState = " + UniqueName(stateMachine.defaultState) + ";");
generatedCode.AppendLine("\t\t\t" + uniqueStateMachineName + ".entryPosition = " + Vector3String(stateMachine.entryPosition) + ";");
generatedCode.AppendLine("\t\t\t" + uniqueStateMachineName + ".exitPosition = " + Vector3String(stateMachine.exitPosition) + ";");
generatedCode.AppendLine("\t\t\t" + uniqueStateMachineName + ".parentStateMachinePosition = " + Vector3String(stateMachine.parentStateMachinePosition) + ";");
generatedCode.AppendLine();
}
