private AnimatorState(AssetLayout layout, AssetInfo assetInfo, AnimatorController controller, int stateMachineIndex, int stateIndex, Vector3f position) :
base(layout)
{
AssetInfo = assetInfo;
ObjectHideFlags = HideFlags.HideInHierarchy;
VirtualSerializedFile virtualFile = (VirtualSerializedFile)assetInfo.File;
IReadOnlyDictionary <uint, string> TOS = controller.TOS;
if (!TOS.ContainsKey(0))
{
Dictionary <uint, string> tos = new Dictionary <uint, string>()
{
{ 0, string.Empty }
};
tos.AddRange(controller.TOS);
TOS = tos;
}
StateMachineConstant stateMachine = controller.Controller.StateMachineArray[stateMachineIndex].Instance;
StateConstant state = stateMachine.StateConstantArray[stateIndex].Instance;
Name = TOS[state.NameID];
Speed = state.Speed;
CycleOffset = state.CycleOffset;
// skip Transitions because not all state exists at this moment
// exclude StateMachine's behaviours
int layerIndex = controller.Controller.GetLayerIndexByStateMachineIndex(stateMachineIndex);
PPtr <MonoBehaviour>[] machineBehaviours = controller.GetStateBehaviours(layerIndex);
PPtr <MonoBehaviour>[] stateBehaviours = controller.GetStateBehaviours(stateMachineIndex, stateIndex);
List <PPtr <MonoBehaviour> > behaviours = new List <PPtr <MonoBehaviour> >(stateBehaviours.Length);
foreach (PPtr <MonoBehaviour> ptr in stateBehaviours)
{
#warning TEMP: remove comment when AnimatorStateMachine's child StateMachines has been implemented
//if (!machineBehaviours.Contains(ptr))
{
behaviours.Add(ptr);
}
}
StateMachineBehaviours = behaviours.ToArray();
Position = position;
IKOnFeet = state.IKOnFeet;
WriteDefaultValues = state.GetWriteDefaultValues(controller.File.Version);
Mirror = state.Mirror;
SpeedParameterActive = state.SpeedParamID > 0;
MirrorParameterActive = state.MirrorParamID > 0;
CycleOffsetParameterActive = state.CycleOffsetParamID > 0;
TimeParameterActive = state.TimeParamID > 0;
Motion = state.CreateMotion(virtualFile, controller, 0);
Tag = TOS[state.TagID];
SpeedParameter = TOS[state.SpeedParamID];
MirrorParameter = TOS[state.MirrorParamID];
CycleOffsetParameter = TOS[state.CycleOffsetParamID];
TimeParameter = TOS[state.TimeParamID];
}
public static BlendTree CreateVirtualInstance(VirtualSerializedFile virtualFile, AnimatorController controller, StateConstant state, int nodeIndex)
{
return(virtualFile.CreateAsset((assetInfo) => new BlendTree(assetInfo, controller, state, nodeIndex)));
}
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;
}
public ChildMotion(VirtualSerializedFile file, AnimatorController controller, StateConstant state, int nodeIndex, int childIndex)
{
BlendTreeConstant treeConstant = state.GetBlendTree();
BlendTreeNodeConstant node = treeConstant.NodeArray[nodeIndex].Instance;
int childNodeIndex = (int)node.ChildIndices[childIndex];
Motion = state.CreateMotion(file, controller, childNodeIndex);
Threshold = node.GetThreshold(controller.File.Version, childIndex);
Position = default;
TimeScale = 1.0f;
CycleOffset = node.CycleOffset;
uint directID = node.GetDirectBlendParameter(controller.File.Version, childIndex);
DirectBlendParameter = controller.TOS[directID];
Mirror = node.Mirror;
}
public AnimatorStateMachine(VirtualSerializedFile file, AnimatorController controller, int stateMachineIndex) :
base(file.CreateAssetInfo(ClassIDType.AnimatorStateMachine))
{
ObjectHideFlags = 1;
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 = new AnimatorState(file, controller, stateMachineIndex, stateIndex, position);
ChildAnimatorState childState = new ChildAnimatorState(state, position);
m_childStates[stateIndex] = childState;
states.Add(state);
}
}
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;
for (int j = 0; j < stateConstant.TransitionConstantArray.Count; j++)
{
long stateTransitionPath = state.Transitions[j].PathID;
AnimatorStateTransition transition = (AnimatorStateTransition)file.GetAsset(stateTransitionPath);
TransitionConstant transitionConstant = stateConstant.TransitionConstantArray[j].Instance;
if (!transitionConstant.IsExit)
{
AnimatorState destState = states[transitionConstant.DestinationState];
transition.DstState = PPtr <AnimatorState> .CreateVirtualPointer(destState);
}
}
}
m_anyStateTransitions = new PPtr <AnimatorStateTransition> [stateMachine.AnyStateTransitionConstantArray.Count];
for (int i = 0; i < stateMachine.AnyStateTransitionConstantArray.Count; i++)
{
TransitionConstant transitionConstant = stateMachine.AnyStateTransitionConstantArray[i].Instance;
AnimatorStateTransition transition = new AnimatorStateTransition(file, controller, transitionConstant, states);
m_anyStateTransitions[i] = PPtr <AnimatorStateTransition> .CreateVirtualPointer(transition);
}
m_entryTransitions = stateMachine.GetEntryTransitions(file, controller, layer.Binding, states);
m_stateMachineBehaviours = new PPtr <MonoBehaviour> [0];
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;
file.AddAsset(this);
}
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;
}
private BlendTree(AssetLayout layout, AssetInfo assetInfo, AnimatorController controller, StateConstant state, int nodeIndex) :
base(layout)
{
AssetInfo = assetInfo;
ObjectHideFlags = HideFlags.HideInHierarchy;
VirtualSerializedFile virtualFile = (VirtualSerializedFile)assetInfo.File;
BlendTreeNodeConstant node = state.GetBlendTree().NodeArray[nodeIndex].Instance;
Name = nameof(BlendTree);
Childs = new ChildMotion[node.ChildIndices.Length];
for (int i = 0; i < node.ChildIndices.Length; i++)
{
Childs[i] = new ChildMotion(virtualFile, controller, state, nodeIndex, i);
}
BlendParameter = node.BlendEventID == uint.MaxValue ? string.Empty : controller.TOS[node.BlendEventID];
BlendParameterY = node.BlendEventYID == uint.MaxValue ? string.Empty : controller.TOS[node.BlendEventYID];
MinThreshold = node.GetMinThreshold(controller.File.Version);
MaxThreshold = node.GetMaxThreshold(controller.File.Version);
UseAutomaticThresholds = false;
NormalizedBlendValues = node.BlendDirectData.Instance.NormalizedBlendValues;
BlendType = node.BlendType;
}
