private void SetStateTransitions(AnimatorStateTransition transition)
{
if (transition.conditions.Length == 0)
{
transition.hasExitTime = true;
transition.exitTime = 1;
transition.hasFixedDuration = false;
transition.duration = 0;
return;
}
foreach (var condition in transition.conditions)
{
if (condition.parameter == "Init")
{
transition.hasExitTime = false;
transition.exitTime = 0;
transition.hasFixedDuration = false;
transition.duration = 0;
return;
}
}
transition.hasExitTime = this.transition.exitTime > 0;
transition.exitTime = this.transition.exitTime > 0 ? this.transition.exitTime : 0;
transition.hasFixedDuration = false;
transition.duration = this.transition.duration;
}
void ConnectBlendTrees(int offset, AnimatorState[] blendTrees, int layer)
{
int c = blendTrees.Length;
for (int i = 0; i < c; i++)
{
for (int j = 0; j < c; j++)
{
if (i == j)
{
continue;
}
AnimatorStateTransition exit = blendTrees[i].AddTransition(blendTrees[j]);
//exit.AddCondition(AnimatorConditionMode.Equals, i, CustomAnimator.sActiveLoop);
exit.AddCondition(AnimatorConditionMode.Equals, j + offset, CustomAnimator.activeLoopParamStrings[layer]);
exit.canTransitionToSelf = false; // false;// true;
exit.interruptionSource = TransitionInterruptionSource.None; // TransitionInterruptionSource.Destination;
exit.hasExitTime = false;
// exit.exitTime = exit_time;
exit.hasFixedDuration = true;
exit.duration = exitTransitionDuration;
}
}
}
static AnimatorState AddState(AnimatorController control, string clipName, bool loop = false, bool addParam = false, bool defaultState = false)
{
AnimatorStateMachine rootStateMachine = control.layers[0].stateMachine;
AnimatorState tempState = rootStateMachine.AddState(clipName);
AnimationClip tempClip = new AnimationClip()
{
name = clipName
};
tempState.motion = tempClip;
if (defaultState)
{
rootStateMachine.defaultState = tempState;
}
if (addParam)
{
AddParam(control, clipName);
AnimatorStateTransition tempTransition = rootStateMachine.AddAnyStateTransition(tempState);
tempTransition.AddCondition(AnimatorConditionMode.If, 0, clipName);
tempTransition.duration = 0;
}
AssetDatabase.AddObjectToAsset(tempClip, control);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(tempClip));
return(tempState);
}
public Transition AnimatorTransitionToCodeTransition(AnimatorStateTransition animatorStateTransition)
{
var dstAnimatorState = animatorStateTransition.destinationState;
var transition = (Transition)Enum.Parse(typeof(Transition), string.Format("To{0}", dstAnimatorState.name));
return(transition);
}
/// <summary>
/// 创建动画控制器
/// </summary>
/// <param name="obj"></param>
/// <param name="path"></param>
/// <returns></returns>
private static AnimatorController CreateAnimatorController(Object obj, string path)
{
string assetPath = AssetDatabase.GetAssetPath(obj);
AnimationClip animationClip = AssetDatabase.LoadAssetAtPath <AnimationClip>(assetPath);
AnimatorController animatorController = AnimatorController.CreateAnimatorControllerAtPath(path + "/" + obj.name + ".controller");
animatorController.AddParameter("isLoop", AnimatorControllerParameterType.Bool);
AnimatorControllerLayer animatorControllerLayer = animatorController.layers[0];
AnimatorStateMachine animatorStateMachine = animatorControllerLayer.stateMachine;
AnimatorState animatorState = animatorStateMachine.AddState(animationClip.name);
animatorState.motion = animationClip;
AnimatorState emptyState = animatorStateMachine.AddState("Empty", new Vector3(animatorStateMachine.entryPosition.x + 400,
animatorStateMachine.entryPosition.y + 400, 0));
AnimatorStateTransition animatorStateTransition = animatorState.AddTransition(emptyState);
animatorStateTransition.hasExitTime = true;
animatorStateTransition = emptyState.AddTransition(animatorState);
animatorStateTransition.AddCondition(AnimatorConditionMode.If, 1, "isLoop");
return(animatorController);
}
public static void autioBuildController()
{
AnimatorController animatorController = AnimatorController.CreateAnimatorControllerAtPath("Assets/animation.controller");
AnimatorControllerLayer layer = animatorController.layers[0];
//clip文件名
List <string> list = new List <string>();
list.Add("AccountToRoot");
list.Add("root");
for (int i = 0; i < list.Count; i++)
{
//文件路径
string path = string.Format("Assets/Res/Ani/cam/{0}.anim", list[i]);
AnimationClip clip = AssetDatabase.LoadAssetAtPath <AnimationClip>(path);
if (clip != null)
{
AnimatorStateMachine stateMachine = layer.stateMachine;
AnimatorState state = stateMachine.AddState(clip.name);
state.motion = clip;
//相当于 AnimatorController 中的连线
AnimatorStateTransition transition = stateMachine.AddAnyStateTransition(state);
}
else
{
Debug.Log("路径找不到 animation clip文件 ");
}
}
AssetDatabase.SaveAssets();
}
protected AnimatorStateTransition CreateAnyTransition(AnimatorState state,
float duration = 0.1f, bool allowTransitToSelf = true)
{
var any = stateMachine.anyStateTransitions;
AnimatorStateTransition transition = null;
foreach (var t in any)
{
if (t.name == state.name)
{
transition = t;
break;
}
}
if (transition == null)
{
CreateTriggerParameter(state.name);
transition = stateMachine.AddAnyStateTransition(state);
transition.name = state.name;
transition.AddCondition(AnimatorConditionMode.If, 0, state.name);
}
transition.duration = duration;
transition.canTransitionToSelf = allowTransitToSelf;
// LogUtil.Debug("cantransitoself " + allowTransitToSelf.ToString());
return(transition);
}
void Create()
{
AnimatorController controller = AnimatorController.CreateAnimatorControllerAtPath("Assets/" + target.name + ".controller");
// Adds a float parameter called Speed
controller.AddParameter("Speed", AnimatorControllerParameterType.Float);
//Add states
AnimatorState idleState = controller.layers[0].stateMachine.AddState("Idle");
idleState.motion = idleAnim;
//Blend tree creation
BlendTree blendTree;
AnimatorState moveState = controller.CreateBlendTreeInController("Move", out blendTree);
//BlendTree setup
blendTree.blendType = BlendTreeType.Simple1D;
blendTree.blendParameter = "Speed";
blendTree.AddChild(walkAnim);
blendTree.AddChild(runAnim);
AnimatorStateTransition LeaveIdle = idleState.AddTransition(moveState);
AnimatorStateTransition leaveMove = moveState.AddTransition(idleState);
LeaveIdle.AddCondition(AnimatorConditionMode.Greater, 0.01f, "Speed");
leaveMove.AddCondition(AnimatorConditionMode.Less, 0.01f, "Speed");
target.GetComponent <Animator>().runtimeAnimatorController = controller;
}
//创建默认状态
private AnimatorState CreateDefaultState(AnimatorStateMachine stateMachine, List <AnimationClip> clips, string stateName, AnimatorState idleState = null, int stateIndex = 0)
{
float posX = stateIndex == 0 ? stateMachine.entryPosition.x : stateMachine.entryPosition.x + 300;
float posY = stateIndex == 0 ? stateMachine.entryPosition.y - 200 : stateMachine.entryPosition.y - 200 + 50 * stateIndex;
Vector2 statePos = new Vector2(posX, posY);
AnimatorState defaultState = stateMachine.AddState(stateName, statePos);
foreach (var item in clips)
{
if (item.name.Contains(stateName))
{
defaultState.motion = item;
break;
}
}
if (idleState == null)
{
ConnectAnyState(stateMachine, defaultState, stateName);
}
else
{
//都要连Idle
AnimatorStateTransition stateTransition = ConnectAnyStateByTrigger(stateMachine, defaultState, stateName + "_state");
stateTransition.AddCondition(AnimatorConditionMode.If, 0, stateName);
ConnectIdleStateByBool(defaultState, idleState, stateName + "_state");
}
return(defaultState);
}
/// <summary>
/// 添加状态之间的连线
/// </summary>
/// <param name="stateM">状态</param>
/// <param name="ani_name"></param>
/// <param name="ani_des"></param>
/// <param name="flag"></param>
static void AddTransition(AnimatorStateMachine stateM, string ani_name, string ani_des, int flag)
{
foreach (var item in stateM.states)
{
if (item.state.name == ani_name)
{
foreach (var des in stateM.states)
{
if (des.state.name == ani_des)
{
AnimatorStateTransition transition = item.state.AddTransition(des.state); //添加连线
transition.hasExitTime = true;
transition.exitTime = 0.8f;
if (flag == 1)
{
transition.AddCondition(AnimatorConditionMode.If, flag, ani_des); //添加连线状态
}
else
{
transition.AddCondition(AnimatorConditionMode.IfNot, flag, ani_name);
}
}
}
}
}
Resources.UnloadUnusedAssets(); //卸载资源
}
/// <summary>
/// 给预制体添加动画
/// </summary>
/// <param name="obj"></param>
/// <param name="modelPath"></param>
/// <param name="animatorControllerPath"></param>
/// <param name="name"></param>
public static void SetAnimatorController(GameObject obj, string modelPath, string animatorControllerPath, string name)
{
Animator anim = obj.GetComponent <Animator>();
if (anim)
{
AnimatorController controller = AnimatorController.CreateAnimatorControllerAtPath(animatorControllerPath + name + ".controller");
AnimatorController.SetAnimatorController(anim, controller);
AnimatorControllerLayer layer = controller.layers[0];
AnimatorStateMachine machine = layer.stateMachine;
controller.AddParameter("e", AnimatorControllerParameterType.Bool);
AnimatorState IdleState = machine.AddState("Idle", new Vector3(300, 0, 0));
machine.defaultState = IdleState;
AnimatorState behaviorState = machine.AddState("behavior", new Vector3(550, 0, 0));
behaviorState.motion = GetAnimationClip(modelPath);
AnimatorStateTransition behaviorTrue = IdleState.AddTransition(behaviorState);
behaviorTrue.AddCondition(AnimatorConditionMode.If, 1f, "e");
AnimatorStateTransition behaviorFlas = behaviorState.AddTransition(IdleState);
behaviorFlas.AddCondition(AnimatorConditionMode.IfNot, 1F, "e");
}
else
{
Debug.Log(obj.name + "没有挂载动画状态机组件");
}
}
public void setTransition()
{
if (tran == null)
{
tran = targetController.layers[0].stateMachine.AddAnyStateTransition(state);
tran.duration = 0;
tran.hasFixedDuration = false;
tran.hasExitTime = false;
tran.canTransitionToSelf = false;
}
AnimatorCondition animatorCondition = new AnimatorCondition();
animatorCondition.mode = AnimatorConditionMode.Equals;
animatorCondition.parameter = "WeaponNumber";
animatorCondition.threshold = weaponNumber;
var cons = tran.conditions;
for (int i = 0; i < cons.Length; i++)
{
tran.RemoveCondition(cons[i]);
}
tran.AddCondition(AnimatorConditionMode.Equals, weaponNumber, "WeaponNumber");
tran.AddCondition(AnimatorConditionMode.Equals, comboCount, "ComboCount");
tran.AddCondition(AnimatorConditionMode.Equals, stateNumber, "State");
if (oneShot)
{
tran.canTransitionToSelf = true;
tran.AddCondition(AnimatorConditionMode.If, 0, "OneShot");
}
}
private void AddDefaultState(AnimatorController ac, int i)
{
AnimatorControllerLayer layer = ac.layers[i];
AnimatorStateMachine stateMachine = layer.stateMachine;
layer.defaultWeight = 1.0f;
string strEmptyNameParam = "Empty" + i;
//每层必须先加一个空状态
AnimatorState stateEmpty = stateMachine.AddState(strEmptyNameParam, new Vector3(stateMachine.entryPosition.x + 300, stateMachine.entryPosition.y, 0));
//添加trigger参数
ac.AddParameter(strEmptyNameParam, AnimatorControllerParameterType.Trigger);
//添加速度修正参数
AnimatorControllerParameter acpEmpty = new AnimatorControllerParameter();
string strSpeedParamEmpty = strEmptyNameParam + "speed";
acpEmpty.name = strSpeedParamEmpty;
acpEmpty.defaultFloat = 1.0f;
acpEmpty.type = AnimatorControllerParameterType.Float;
ac.AddParameter(acpEmpty);
//添加Any到Empty的transition
AnimatorStateTransition ToEmptyTransition = stateMachine.AddAnyStateTransition(stateEmpty);
ToEmptyTransition.AddCondition(AnimatorConditionMode.If, 0, strEmptyNameParam);
ToEmptyTransition.duration = 0f;
ToEmptyTransition.name = strEmptyNameParam;
m_LayerDefaultState.Add(i, stateEmpty);
}
private static void ImportTransitions(AnimatorStateMachine stateMachine, ChildAnimatorState[] states)
{
var transitionEquality = new TransitionEqualityComparer();
foreach (var state in states)
{
foreach (var transition in state.state.transitions)
{
var fromState = FindStateByName(stateMachine, state.state.name);
var toState = FindStateByName(stateMachine, transition.destinationState.name);
AnimatorStateTransition newTransition = new AnimatorStateTransition();
newTransition.destinationState = toState;
var originalCondition = transition.conditions[0];
var conditionCopy = new AnimatorCondition();
conditionCopy.mode = originalCondition.mode;
conditionCopy.parameter = originalCondition.parameter;
conditionCopy.threshold = originalCondition.threshold;
newTransition.conditions = new AnimatorCondition[]
{
conditionCopy
};
if (!fromState.transitions.Contains(newTransition, transitionEquality))
{
fromState.AddTransition(newTransition);
}
}
}
}
static void SetupAnimatorStateTransition(AnimatorStateTransition transition, float duration, bool hasExitTime, float exitTime, bool canTransitionToSelf)
{
transition.duration = duration;
transition.hasExitTime = hasExitTime;
transition.exitTime = exitTime;
transition.canTransitionToSelf = canTransitionToSelf;
}
public void AddTransition(EditorAnimationItem Anim, AnimatorConditionMode mode, float v, string parameter, bool hasExitTime = true)
{
AnimatorStateTransition st = state.AddTransition(Anim.state);
st.AddCondition(mode, v, parameter);
st.hasExitTime = hasExitTime;
}
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 void Build()
{
var expName = _expressionInfo.ExpressionName;
var controller = _expressionInfo.Controller;
AnimatorControllerLayer layer = AnimUtility.AddLayer(controller, expName, _dirtyAssets);
controller.AddParameter(expName, AnimatorControllerParameterType.Bool);
AnimatorStateMachine stateMachine = layer.stateMachine;
var empty = AnimUtility.AddState(stateMachine, "Empty", true, _dirtyAssets);
AnimatorState toggleState = AnimUtility.AddState(stateMachine, expName, false, _dirtyAssets);
var animationClip = AnimUtility.CreateAnimation(_expressionInfo.AnimationsFolder.GetPath(), expName, _dirtyAssets);
toggleState.motion = animationClip;
foreach (var obj in GetObjects())
{
switch (obj.Type)
{
case AdvancedToggleObjectMode.GameObject:
AddToggleKeyframes(animationClip, obj.Target as Transform, obj.ToggleState, _dirtyAssets);
break;
case AdvancedToggleObjectMode.Material:
AnimUtility.SetObjectReferenceKeyframe(animationClip, obj.Target, $"m_Materials.Array.data[{obj.MaterialSlot}]", obj.NewMaterial, _dirtyAssets);
break;
}
}
AnimatorStateTransition anyStateTransition = stateMachine.AddAnyStateTransition(toggleState);
anyStateTransition.AddCondition(AnimatorConditionMode.If, 1, expName);
AnimatorStateTransition exitTransition = toggleState.AddExitTransition(false);
exitTransition.AddCondition(AnimatorConditionMode.IfNot, 0, expName);
AnimUtility.AddVRCExpressionsParameter(_expressionInfo.AvatarDescriptor, VRCExpressionParameters.ValueType.Bool, expName, _dirtyAssets);
if (_expressionInfo.Menu != null)
{
AnimUtility.AddVRCExpressionsMenuControl(_expressionInfo.Menu, ControlType.Toggle, expName, _dirtyAssets);
}
_dirtyAssets.SetDirty();
controller.AddObjectsToAsset(stateMachine, toggleState, anyStateTransition, exitTransition, empty);
AssetDatabase.SaveAssets();
_dirtyAssets.Clear();
foreach (ObjectData obj in GetObjects().Where(o => o.Type == AdvancedToggleObjectMode.Parameter))
{
AnimUtility.AddVRCParameterDriver(toggleState, obj.ParameterName, obj.ParameterValue, _dirtyAssets);
}
_dirtyAssets.SetDirty();
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
internal static void SetupCommonTransition(AnimatorStateTransition transition)
{
transition.hasExitTime = false;
transition.exitTime = 0;
transition.hasFixedDuration = true;
transition.offset = 0;
transition.interruptionSource = TransitionInterruptionSource.None;
}
public static bool HasCondition(this AnimatorStateTransition obj, string parameter, AnimatorConditionMode mode, float threshold)
{
var condition = new AnimatorCondition {
parameter = parameter, mode = mode, threshold = threshold
};
return(obj.HasCondition(condition));
}
internal static void SetupDefaultTransition(AnimatorStateTransition transition)
{
SetupCommonTransition(transition);
transition.duration = 0.1f; // There seems to be a quirk if the duration is 0 when using DisableExpressions, so use 0.1f instead
transition.orderedInterruption = true;
transition.canTransitionToSelf = false;
}
private void SetGestureTransitionDefaults(AnimatorStateTransition transition)
{
transition.hasExitTime = false;
transition.hasFixedDuration = false;
transition.duration = .01f;
transition.interruptionSource = TransitionInterruptionSource.Destination;
transition.canTransitionToSelf = false;
}
public static void ConvertTransitionToContinue()
{
Hashtable stateConditionTable = new Hashtable();
AnimatorStateMachine stateMachine = null;
setHashTable(out stateConditionTable);
List <string> nameOfStates = new List <string>();
List <AnimatorStateTransition> animatorStateTransitionList = new List <AnimatorStateTransition>();
foreach (Object obj in Selection.objects)
{
if (obj.GetType() == typeof(AnimatorStateMachine))
{
stateMachine = (obj as AnimatorStateMachine);
foreach (ChildAnimatorState state in stateMachine.states)
{
if (animatorStateTransitionList.Count > 0)
{
animatorStateTransitionList.RemoveRange(0, animatorStateTransitionList.Count);
}
if (nameOfStates.Count > 0)
{
nameOfStates.RemoveRange(0, nameOfStates.Count);
}
foreach (AnimatorStateTransition stateTransition in state.state.transitions)
{
nameOfStates.Add(stateTransition.destinationState.name);
setTransition(stateTransition,
(float)stateConditionTable[stateTransition.destinationState.name.ToLower()]);
animatorStateTransitionList.Add(stateTransition);
}
foreach (ChildAnimatorState _state in stateMachine.states)
{
if (_state.state.name.CompareTo(state.state.name) != 0 && !nameOfStates.Contains(_state.state.name))
{
AnimatorStateTransition newState = new AnimatorStateTransition();
newState.destinationState = _state.state;
animatorStateTransitionList.Add(newState);
setTransition(newState, (float)stateConditionTable[_state.state.name.ToLower()]);
if (AssetDatabase.GetAssetPath(stateMachine) != "")
{
AssetDatabase.AddObjectToAsset(newState, AssetDatabase.GetAssetPath(stateMachine));
}
}
}
state.state.transitions = animatorStateTransitionList.ToArray();
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
private void CopyTransitionForPreview(AnimatorStateTransition src, ref AnimatorStateTransition dst)
{
if (src != null)
{
dst.duration = src.duration;
dst.offset = src.offset;
dst.exitTime = src.exitTime;
}
}
public void Build()
{
var expName = _expressionInfo.ExpressionName;
var controller = _expressionInfo.Controller;
AnimatorControllerLayer layer = AnimUtility.AddLayer(controller, expName, _dirtyAssets);
controller.AddParameter(expName, AnimatorControllerParameterType.Float);
AnimatorStateMachine stateMachine = layer.stateMachine;
var empty = AnimUtility.AddState(stateMachine, "Empty", true, _dirtyAssets);
AnimatorState state = AnimUtility.AddState(stateMachine, expName, false, _dirtyAssets);
var blendTree = new BlendTree
{
name = "BlendTree",
blendParameter = expName,
};
state.motion = blendTree;
_dirtyAssets.Add(blendTree);
var materials = GetMaterials().ToList();
var directory = $"{_expressionInfo.AnimationsFolder.GetPath()}/{expName}";
var emptyClip = AnimUtility.CreateAnimation(directory, $"{expName}_{empty}", _dirtyAssets);
blendTree.AddChild(emptyClip);
for (var i = 0; i < materials.Count; i++)
{
Material material = materials[i];
var animationClip = AnimUtility.CreateAnimation(directory, $"{expName} [{i}] {material.name}", _dirtyAssets);
AnimUtility.SetObjectReferenceKeyframe(animationClip, _renderer, $"m_Materials.Array.data[{_materialSlot}]", material, _dirtyAssets);
blendTree.AddChild(animationClip);
_dirtyAssets.Add(animationClip);
}
AnimatorStateTransition anyStateTransition = stateMachine.AddAnyStateTransition(state);
anyStateTransition.AddCondition(AnimatorConditionMode.Greater, 0.01f, expName);
AnimatorStateTransition exitTransition = state.AddExitTransition(false);
exitTransition.AddCondition(AnimatorConditionMode.Less, 0.01f, expName);
AnimUtility.AddVRCExpressionsParameter(_expressionInfo.AvatarDescriptor, VRCExpressionParameters.ValueType.Float, expName, _dirtyAssets);
if (_expressionInfo.Menu != null)
{
AnimUtility.AddVRCExpressionsMenuControl(_expressionInfo.Menu, ControlType.RadialPuppet, expName, _dirtyAssets);
}
_dirtyAssets.SetDirty();
controller.AddObjectsToAsset(stateMachine, empty, state, anyStateTransition, exitTransition, blendTree);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
static void AddTransition(AnimatorState start, AnimatorState end, string condition, float _duration = 0)
{
AnimatorStateTransition tempTransition = start.AddExitTransition();
tempTransition.destinationState = end;
tempTransition.hasExitTime = false;
tempTransition.AddCondition(AnimatorConditionMode.If, 0, condition);
tempTransition.duration = _duration;
}
static void AddExit(AnimatorState start, AnimatorState end, float _exitTime = 1, float _duration = 0)
{
AnimatorStateTransition tempTransition = start.AddExitTransition();
tempTransition.destinationState = end;
tempTransition.hasExitTime = true;
tempTransition.exitTime = _exitTime;
tempTransition.duration = _duration;
}
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);
}
}
}
}
private static void SetupTransition(AnimatorStateTransition toListening)
{
toListening.hasExitTime = false;
toListening.exitTime = 0f;
toListening.hasFixedDuration = true;
toListening.duration = 0;
toListening.offset = 0;
toListening.interruptionSource = TransitionInterruptionSource.None;
toListening.orderedInterruption = true;
}
protected void AddDirectionTransitionA2BIfNotExist(AnimatorState stateA, AnimatorState stateB, int angle)
{
AnimatorStateTransition transition = FindTransitionA2B(stateA, stateB);
if (transition == null)
{
transition = stateA.AddTransition(stateB);
}
RemoveAllAndAddCondition(transition, ANGLE_PARAM_NAME, AnimatorConditionMode.Equals, angle);
}
