/// <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(); //卸载资源
}
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 static void AddStateTransition(AnimatorController ctrl, string path, AnimatorControllerLayer layer)
{
AnimatorStateMachine sm = layer.stateMachine;
//根据动画文件读取它的AnimationClip对象
Object[] objs = AssetDatabase.LoadAllAssetsAtPath(path);
List <AnimationClip> clips = new List <AnimationClip>();
for (int i = 0; i < objs.Length; i++)
{
AnimationClip clip = objs[i] as AnimationClip;
if (clip != null && clip.name.IndexOf("__preview__") == -1)
{
clips.Add(clip);
}
}
AnimatorState idleState = null;
List <AnimatorState> otherStates = new List <AnimatorState>();
foreach (AnimationClip newClip in clips)
{
AnimatorState state = sm.AddState(newClip.name);
state.motion = newClip;
if (newClip.name == CreateAnimatorController.IdleName)
{
idleState = state;
}
else
{
string cond = string.Format("{0}_{1}", CreateAnimatorController.IdleName, newClip.name);
ctrl.AddParameter(cond, AnimatorControllerParameterType.Bool);
cond = string.Format("{1}_{0}", CreateAnimatorController.IdleName, newClip.name);
ctrl.AddParameter(cond, AnimatorControllerParameterType.Bool);
otherStates.Add(state);
}
}
sm.defaultState = idleState;
foreach (AnimatorState state in otherStates)
{
string cond = string.Format("{0}_{1}", CreateAnimatorController.IdleName, state.motion.name);
AnimatorStateTransition tran = idleState.AddTransition(state);
tran.AddCondition(AnimatorConditionMode.If, 0, cond);
cond = string.Format("{1}_{0}", CreateAnimatorController.IdleName, state.motion.name);
tran = state.AddTransition(idleState);
tran.AddCondition(AnimatorConditionMode.If, 0, cond);
}
}
public static void ChangeTransition(AnimatorStateTransition transition, ChildAnimatorState childState, int name, bool value)
{
transition.destinationState = childState.state;
transition.conditions = new AnimatorCondition[0];
switch (value)
{
case true:
transition.AddCondition(AnimatorConditionMode.If, 0, "Inventory " + name);
break;
case false:
transition.AddCondition(AnimatorConditionMode.IfNot, 0, "Inventory " + name);
break;
}
}
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);
}
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;
}
}
}
/// <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 + "没有挂载动画状态机组件");
}
}
/// <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);
}
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 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;
}
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);
}
//创建默认状态
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);
}
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;
}
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();
}
private void CreateToggleLayer()
{
string layerName = "ToggleMarker";
AnimatorControllerLayer layer = FindLayer(layerName);
if (layer == null)
{
layer = new AnimatorControllerLayer();
layer.name = layerName;
layer.stateMachine = new AnimatorStateMachine();
layer.stateMachine.name = layerName;
layer.stateMachine.hideFlags = HideFlags.HideInHierarchy;
if (AssetDatabase.GetAssetPath(fxController) != "")
{
AssetDatabase.AddObjectToAsset(layer.stateMachine, AssetDatabase.GetAssetPath(fxController));
}
layer.blendingMode = AnimatorLayerBlendingMode.Override;
layer.defaultWeight = 1.0f;
AnimatorState MarkerOffState = layer.stateMachine.AddState("MarkerOff");
AnimatorState MarkerOnState = layer.stateMachine.AddState("MarkerOn");
AnimatorStateTransition transition = MarkerOffState.AddTransition(MarkerOnState);
transition.AddCondition(AnimatorConditionMode.Equals, 1, "ToggleMarker");
transition.hasExitTime = false;
transition.hasFixedDuration = false;
transition.duration = 0;
transition.interruptionSource = TransitionInterruptionSource.Destination;
transition.canTransitionToSelf = false;
transition = MarkerOnState.AddTransition(MarkerOffState);
transition.AddCondition(AnimatorConditionMode.Equals, 0, "ToggleMarker");
transition.hasExitTime = false;
transition.hasFixedDuration = false;
transition.duration = 0;
transition.interruptionSource = TransitionInterruptionSource.Destination;
transition.canTransitionToSelf = false;
WriteToggleAnimations();
MarkerOffState.motion = toggleOffClip;
MarkerOnState.motion = toggleOnClip;
fxController.AddLayer(layer);
}
}
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;
}
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 ParseTransitionParam(string val, AnimatorStateTransition transition)
{
if (string.IsNullOrEmpty(val) || val.Equals('0'))
{
return;
}
Debug.LogError(val);
string[] parms = val.Split(',');
for (int i = 0; i < parms.Length; i++)
{
int id = int.Parse(parms[i]);
AnimatorTransfer transfer = InfoMgr <AnimatorTransfer> .Instance.GetInfo(id);
if (null != transfer)
{
switch (transfer.type)
{
case TransferValue.TransferValue_BOOL:
if (transfer.value == 1)
{
transition.AddCondition(AnimatorConditionMode.If, transfer.value, transfer.param.ToString());
}
else if (transfer.value == 0)
{
transition.AddCondition(AnimatorConditionMode.IfNot, transfer.value, transfer.param.ToString());
}
break;
case TransferValue.TransferValue_INT:
transition.AddCondition(AnimatorConditionMode.Equals, transfer.value, transfer.param.ToString());
break;
case TransferValue.TransferValue_TRIGGER:
transition.AddCondition(AnimatorConditionMode.If, transfer.value, transfer.param.ToString());
break;
case TransferValue.TransferValue_EXIT:
//transition.AddCondition(AnimatorConditionMode.If, transfer.value, transfer.param.ToString());
transition.hasExitTime = true;
break;
}
}
}
}
private static AnimatorStateTransition AddTransition(string fromName, string toName,
params object[] conditions)
{
AnimatorState from = null;
if (m_allState.ContainsKey(fromName))
{
from = m_allState[fromName];
}
AnimatorState to = null;
if (m_allState.ContainsKey(toName))
{
to = m_allState[toName];
}
AnimatorStateTransition transition = (from == null ? m_stateMachine.AddAnyStateTransition(to) : from.AddTransition(to));
for (int i = 0; i < conditions.Length;)
{
var name = (string)conditions[i++];
var type = (AnimatorConditionMode)conditions[i++];
if (type == AnimatorConditionMode.If || type == AnimatorConditionMode.IfNot)
{
i++;
transition.AddCondition(type, 0, name);
}
else
{
var arg = (int)conditions[i++];
transition.AddCondition(type, arg, name);
}
}
if (!fromName.StartsWith("idle1"))
{
transition.canTransitionToSelf = false;
}
if (fromName.StartsWith("attack"))
{
transition.hasExitTime = true;
}
return(transition);
}
//Crée un Dialog Controller (Animator Controller) qui a les caractéristiques suivantes :
//Il possède tous les paramètres Triggers et Booléens nécessaires pour être utilisé.
//Un état de départ et des transitions vers 2 états supplémentaires Visited et NotVisited.
//Une transition de retour depuis AnyState permet de revenir à l'état initial dès que le booléen active redevient faux.
//Les transitions sont configurées correctement (pas de durée de transition).
void CreateController()
{
var controller = AnimatorController.CreateAnimatorControllerAtPath("Assets/DialogControllers/" + controllerName + ".controller");
var rootStateMachine = controller.layers[0].stateMachine;
controller.AddParameter(DialogParameters.nextString, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.answer0String, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.answer1String, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.answer2String, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.answer3String, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.itemConditionMetString, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.itemConditionNotMetString, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.valueConditionMetString, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.valueConditionNotMetString, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.randomSuccess, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.randomFailure, AnimatorControllerParameterType.Trigger);
controller.AddParameter(DialogParameters.visitedString, AnimatorControllerParameterType.Bool);
controller.AddParameter(DialogParameters.activeString, AnimatorControllerParameterType.Bool);
AnimatorState startState = rootStateMachine.AddState("Start") as AnimatorState;
rootStateMachine.AddEntryTransition(startState);
AnimatorState notVisitedState = rootStateMachine.AddState("Not Visited") as AnimatorState;
AnimatorStateTransition notVisitedTransition = startState.AddTransition(notVisitedState) as AnimatorStateTransition;
notVisitedTransition.duration = 0f;
notVisitedTransition.AddCondition(AnimatorConditionMode.IfNot, 0, DialogParameters.visitedString);
notVisitedTransition.AddCondition(AnimatorConditionMode.If, 0, DialogParameters.activeString);
AnimatorState visitedState = rootStateMachine.AddState("Visited") as AnimatorState;
AnimatorStateTransition visitedTransition = startState.AddTransition(visitedState) as AnimatorStateTransition;
visitedTransition.duration = 0f;
visitedTransition.AddCondition(AnimatorConditionMode.If, 0, DialogParameters.visitedString);
visitedTransition.AddCondition(AnimatorConditionMode.If, 0, DialogParameters.activeString);
AnimatorStateTransition inactiveTransition = rootStateMachine.AddAnyStateTransition(startState) as AnimatorStateTransition;
inactiveTransition.duration = 0f;
inactiveTransition.AddCondition(AnimatorConditionMode.IfNot, 0, DialogParameters.activeString);
}
private void CopyOrCreateAnyStateTransition(AnimatorStateMachine outStateMachine, AnimatorStateTransition refTransition, AnimatorState outState, int angle)
{
AnimatorStateTransition outTransition = FindAnyStateTransition(outStateMachine, outState);
if (outTransition == null)
{
outTransition = outStateMachine.AddAnyStateTransition(outState);
outTransition.AddCondition(AnimatorConditionMode.Equals, angle, ANGLE_PARAM_NAME);
}
CopyStateTransition(refTransition, outTransition);
}
/// <summary>
/// 触发连任意状态
/// </summary>
/// <param name="stateMachine"></param>
/// <param name="newState"></param>
/// <param name="condName"></param>
/// <returns></returns>
private AnimatorStateTransition ConnectAnyStateByTrigger(AnimatorStateMachine stateMachine, AnimatorState newState, string condName)
{
AnimatorStateTransition _animatorStateTransition = stateMachine.AddAnyStateTransition(newState);
_animatorStateTransition.AddCondition(AnimatorConditionMode.If, 0, condName);
_animatorStateTransition.hasExitTime = false;
_animatorStateTransition.canTransitionToSelf = true;
_animatorStateTransition.offset = 0;
_animatorStateTransition.duration = 0;
return(_animatorStateTransition);
}
//Cette fonction crée un état avec les transitions spécifiées (durée, exit time, et conditions) par le choix dans CreateChildrenStateAndTransitions.
void CreateStatesAndTriggerTransitions(AnimatorStateMachine stateMachine, AnimatorState origin, string[] triggers)
{
string newStateName = stateMachine.MakeUniqueStateName("newState");
AnimatorState newState = stateMachine.AddState(newStateName) as AnimatorState;
AnimatorStateTransition newStateTransition = originState.AddTransition(newState) as AnimatorStateTransition;
newStateTransition.hasExitTime = false;
newStateTransition.duration = 0f;
foreach (string trigger in triggers)
{
newStateTransition.AddCondition(AnimatorConditionMode.If, 0, trigger);
}
}
private static AnimationClip GenerateTriggerableTransition(string name, AnimatorController controller)
{
AnimationClip animationClip = AnimatorController.AllocateAnimatorClip(name);
AssetDatabase.AddObjectToAsset(animationClip, controller);
AnimatorState destinationState = controller.AddMotion(animationClip);
controller.AddParameter(name, AnimatorControllerParameterType.Trigger);
AnimatorStateMachine stateMachine = controller.layers[0].stateMachine;
AnimatorStateTransition animatorStateTransition = stateMachine.AddAnyStateTransition(destinationState);
animatorStateTransition.AddCondition(AnimatorConditionMode.If, 0f, name);
return(animationClip);
}
private static void copyTransition(AnimatorStateTransition originTransition,
AnimatorStateTransition newTransition)
{
foreach (var condition in originTransition.conditions)
{
newTransition.AddCondition(condition.mode, condition.threshold, condition.parameter);
}
newTransition.duration = originTransition.duration;
newTransition.exitTime = originTransition.exitTime;
newTransition.offset = originTransition.offset;
newTransition.hasExitTime = originTransition.hasExitTime;
newTransition.hasFixedDuration = originTransition.hasFixedDuration;
newTransition.mute = originTransition.mute;
newTransition.solo = originTransition.solo;
}
private void ConnectIdleStateByBool(AnimatorState newState, AnimatorState entryState, string condName)
{
if (newState == null || entryState == null)
{
return;
}
AnimatorStateTransition _animatorStateTransition = newState.AddTransition(entryState);
if (newState.name != IdleStateName)
{
_animatorStateTransition.AddCondition(AnimatorConditionMode.IfNot, 0, condName);
}
_animatorStateTransition.hasExitTime = true;
_animatorStateTransition.offset = 0;
_animatorStateTransition.duration = 0;
}
static public void BuildState(XmlState xmlState)
{
AnimatorStateTransition trans = null;
xmlState.animatorState.writeDefaultValues = false;
trans = xmlState.stateMachine.animatorStateMachine.AddAnyStateTransition(xmlState.animatorState);
trans.hasExitTime = true;
trans.exitTime = 0;
trans.duration = 0;
trans.canTransitionToSelf = false;
foreach (XmlCondition xmlCond in xmlState.anyCondList)
{
trans.AddCondition(xmlCond.opMode, xmlCond.getFloatValue(), xmlCond.name);
}
}
void AddState(int indexBlendTreeOffset, AnimatorController controller, AnimatorStateMachine sm, int layer, ClipIDPair clipIDPair, AnimatorState[] blendTrees)
{
if (clipIDPair.layer != layer)
{
return;
}
if (clipIDPair.looped)
{
return;
}
int id = clipIDPair.id;
AnimationClip clip = clipIDPair.clip;
// Add the state to the state machine (The Vector3 is for positioning in the editor window)
AnimatorState state = sm.AddState(id.ToString());//, new Vector3(300, 0, 0));
state.mirrorParameterActive = true;
state.speedParameterActive = true;
state.mirrorParameter = CustomAnimator.mirrorParamStrings[layer];
state.speedParameter = CustomAnimator.speedParamStrings[layer];
// state.mirrorParameter = CustomAnimator.sMirror;
// state.speedParameter = CustomAnimator.sSpeed;
state.tag = CustomAnimator.sShots;
state.motion = clip;
float exit_time = 1.0f - (exitTransitionDuration / clip.length);
int c = blendTrees.Length;
for (int i = 0; i < c; i++)
{
AnimatorStateTransition exit = state.AddTransition(blendTrees[i]);
//exit.AddCondition(AnimatorConditionMode.Equals, i, CustomAnimator.sActiveLoop);
exit.AddCondition(AnimatorConditionMode.Equals, i + indexBlendTreeOffset, CustomAnimator.activeLoopParamStrings[layer]);
exit.canTransitionToSelf = false;
exit.hasExitTime = true;
exit.exitTime = exit_time;
exit.hasFixedDuration = true;
exit.duration = exitTransitionDuration;
}
}
public static void ApplyTo(this AnimatorStateTransition source, AnimatorStateTransition dest)
{
dest.orderedInterruption = source.orderedInterruption;
dest.canTransitionToSelf = source.canTransitionToSelf;
dest.duration = source.duration;
dest.exitTime = source.exitTime;
dest.hasExitTime = source.hasExitTime;
dest.hasFixedDuration = source.hasFixedDuration;
dest.interruptionSource = source.interruptionSource;
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 void UpdateAnimatorController()
{
// The new controller that will be created based on Manager animations
AnimatorController newController = new AnimatorController();
newController.AddLayer("DefaultLayer");
// Add a parameter that will determine the animation states
AnimatorControllerParameter animatorParameter = new AnimatorControllerParameter();
animatorParameter.type = AnimatorControllerParameterType.Int;
animatorParameter.name = "TextAnimation";
animatorParameter.defaultInt = 999;
newController.AddParameter(animatorParameter);
// Add state machine
AnimatorStateMachine rootStateMachine = newController.layers[0].stateMachine;
AnimatorStateMachine stateMachine = rootStateMachine.AddStateMachine("TextAnimationStateMachine");
// Create a default state to prevent animation auto playing index 0
AnimatorState waitingState = stateMachine.AddState("Waiting");
//foreach (AnimationClip clip in DamageNumberManager.instance.animations)
for (int i = 0; i < DamageNumberManager.instance.animations.Length; i++)
{
AnimationClip clip = DamageNumberManager.instance.animations[i];
// Add new state based on the AnimationClip
AnimatorState state = stateMachine.AddState(clip.name);
state.motion = clip;
// Create transition from "Waiting" to the new state
AnimatorStateTransition transition = waitingState.AddTransition(state, false);
transition.AddCondition(AnimatorConditionMode.Equals, i, "TextAnimation");
}
// Override the existing Animator Controller
AnimatorOverrideController overrideController = new AnimatorOverrideController();
overrideController.runtimeAnimatorController = newController;
GetComponent <Animator>().runtimeAnimatorController = overrideController;
}
