/// <summary>
/// 添加动画状态机状态
/// </summary>
/// <param name="path"></param>
/// <param name="layer"></param>
private static void AddStateTranstion(string path, AnimatorControllerLayer layer)
{
AnimatorStateMachine sm = layer.stateMachine;
// 根据动画文件读取它的AnimationClip对象
var datas = AssetDatabase.LoadAllAssetsAtPath(path);
if (datas.Length == 0)
{
Debug.Log(string.Format("Can't find clip in {0}", path));
return;
}
// 先添加一个默认的空状态
var emptyState = sm.AddState("empty");
sm.AddAnyStateTransition(emptyState);
// 遍历模型中包含的动画片段，将其加入状态机中
foreach (var data in datas)
{
if (!(data is AnimationClip))
{
continue;
}
var newClip = data as AnimationClip;
if (newClip.name.StartsWith("__"))
{
continue;
}
// 取出动画名字，添加到state里面
var state = sm.AddState(newClip.name);
state.motion = newClip;
// 把State添加在Layer里面
sm.AddAnyStateTransition(state);
}
}
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 static AnimatorStateTransition AddAnyTransitionDefaultParam(this AnimatorStateMachine stateMachine, AnimatorState destinationState)
{
var transition = stateMachine.AddAnyStateTransition(destinationState);
SetDefaultTransitionParam(transition);
return(transition);
}
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();
}
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);
}
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();
}
public static AnimatorStateTransition AddAnyTransitionDefaultParam(this AnimatorStateMachine stateMachine, AnimatorState destinationState, AnimatorConditionMode mode, float threshold, string parameter)
{
var transition = stateMachine.AddAnyStateTransition(destinationState);
SetDefaultTransitionParam(transition);
transition.AddCondition(mode, threshold, parameter);
return(transition);
}
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();
}
private static AnimatorStateTransition CreateAnyStateTransition(AnimatorStateMachine stateMachine, AnimatorState state, string parameter)
{
var transition = stateMachine.AddAnyStateTransition(state);
transition.AddCondition(AnimatorConditionMode.If, 0, parameter);
transition.duration = m_DefaultDuration;
return(transition);
}
/// <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);
}
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);
}
private void CreateTransitionWhenActivityIsOutOfBounds(AnimatorStateMachine machine, AnimatorState defaultState)
{
var transition = machine.AddAnyStateTransition(defaultState);
SharedLayerUtils.SetupDefaultTransition(transition);
foreach (var layer in _comboLayers)
{
transition.AddCondition(AnimatorConditionMode.NotEqual, layer.stageValue, _activityStageName);
}
}
private static void AddStateTransition(AnimationClip clip, AnimatorControllerLayer layer)
{
AnimatorStateMachine sm = layer.stateMachine;
//取出动画名子 添加到state里面
AnimatorState state = sm.AddState(clip.name);
state.motion = clip;
////把state添加在layer里面
AnimatorStateTransition trans = sm.AddAnyStateTransition(state);
////把默认的时间条件删除
}
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);
}
static AnimatorController BuildAnimationController(List <AnimationClip> clips, string name)
{
AnimatorController animatorController = AnimatorController.CreateAnimatorControllerAtPath(AnimationControllerPath + "/" + name + ".controller");
AnimatorControllerLayer layer = animatorController.layers[0];
AnimatorStateMachine sm = layer.stateMachine;
foreach (AnimationClip newClip in clips)
{
UnityEditor.Animations.AnimatorState state = sm.AddState(newClip.name);
state.motion = newClip;
AnimatorStateTransition trans = sm.AddAnyStateTransition(state);
}
AssetDatabase.SaveAssets();
return(animatorController);
}
static AnimatorController BuildAnimationController(List <AnimationClip> clips, string directoryName, string name)
{
AnimatorController animatorController = AnimatorController.CreateAnimatorControllerAtPath(directoryName + "/" + name + ".controller");
AnimatorControllerLayer layer = animatorController.layers[0];
AnimatorStateMachine asm = layer.stateMachine;
foreach (AnimationClip newClip in clips)
{
AnimatorState state = asm.AddState(newClip.name);
state.motion = newClip;
AnimatorStateTransition trans = asm.AddAnyStateTransition(state);
trans.hasExitTime = false;
}
AssetDatabase.SaveAssets();
return(animatorController);
}
// 单独生成动画控制器
public static AnimatorController BuildAnimationController(List <AnimationClip> clips, string path, string name)
{
AnimatorController animatorController = AnimatorController.CreateAnimatorControllerAtPath(string.Format("{0}/{1}.controller", path, name));
AnimatorControllerLayer layer = animatorController.layers[0];
AnimatorControllerParameter[] parameters = animatorController.parameters;
AnimatorStateMachine sm = layer.stateMachine;
foreach (AnimationClip newClip in clips)
{
AnimatorState state = sm.AddState(newClip.name);
state.motion = newClip;
AnimatorStateTransition trans = sm.AddAnyStateTransition(state);
}
AssetDatabase.SaveAssets();
return(animatorController);
}
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);
}
static void AddSuMechie(AnimatorStateMachine machine, int index1, string path, AnimatorControllerLayer layer, string sunStateMachine)
{
////创建子状态机
//for (int k = 1; k < index1; k++)
//{
// AnimatorStateMachine sub2Machine = machine.AddStateMachine("sub2Machine", new Vector3(100, 300, 0));
//}
AnimatorStateMachine sub2Machine = machine.AddStateMachine(sunStateMachine, new Vector3(100, 300, 0));
// 根据动画文件读取它的AnimationClip对象
var datas = AssetDatabase.LoadAllAssetsAtPath(path);
if (datas.Length == 0)
{
Debug.Log(string.Format("Can't find clip in {0}", path));
return;
}
foreach (var data in datas)
{
int index = 0;
if (!(data is AnimationClip))
{
continue;
}
var newClip = data as AnimationClip;
if (newClip.name.StartsWith("__"))
{
continue;
}
// 取出动画名字，添加到state里面
AnimatorState state = sub2Machine.AddState(newClip.name, new Vector3(500, sub2Machine.states.Length * 60, 0));
stateList.Add(state);
if (state.name == "walk")
{
sub2Machine.defaultState = state;
}
Debug.Log(string.Format("<color=red>{0}</color>", state));
index++;
state.motion = newClip;
// 把State添加在Layer里面
sub2Machine.AddAnyStateTransition(state);
}
}
/// <summary>
/// 生成控制器animator
/// </summary>
static AnimatorController Generate2DAnimator(List <AnimationClip> clips, DirectoryInfo directoryInfo)
{
string controllerFile = s_toAnimatorPath + "/" + directoryInfo.Name + ".controller";
Debug.LogWarningFormat("save controller to path={0}.", controllerFile);
var animatorController = AnimatorController.CreateAnimatorControllerAtPath(controllerFile);
AnimatorStateMachine stateMachine = animatorController.layers[0].stateMachine;
foreach (var clip in clips)
{
AnimatorState animatorState = stateMachine.AddState(clip.name);
animatorState.motion = clip;
var stateTransistion = stateMachine.AddAnyStateTransition(animatorState);
stateTransistion.hasExitTime = true;
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return(animatorController);
}
/// <summary>
/// Show how to relate exitState and anyState
/// </summary>
private void CreateDeath()
{
AnimationClip deathClip = AnimatorFactoryUtil.LoadAnimClip(AnimationPath + "WalkTurn.FBX");
stateDeath = baseLayerMachine.AddState("Death", new Vector3(200f, 100f));
productController.SetStateEffectiveMotion(stateDeath, deathClip);
// death to exit
var exitTransition = stateDeath.AddExitTransition();
exitTransition.AddCondition(AnimatorConditionMode.If, 0, "TriggerA");
exitTransition.duration = 0;
// anyState to death
var anyTransition = baseLayerMachine.AddAnyStateTransition(stateDeath);
anyTransition.AddCondition(AnimatorConditionMode.If, 0, "TriggerB");
anyTransition.duration = 0;
}
public void Build()
{
var expressionActiveState = _controller.ContentFrame.Q <Toggle>("expression-active-state");
var expressionObject = _controller.ContentFrame.Q <ObjectField>("expression-object");
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);
AnimUtility.SetObjectReferenceKeyframe(animationClip, _renderer, $"m_Materials.Array.data[{_materialSlot}]", _material, _dirtyAssets);
_dirtyAssets.Add(animationClip);
toggleState.motion = animationClip;
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();
AssetDatabase.Refresh();
}
private void CreateTransition(int?stageValue, Permutation permutation, AnimatorState state, float transitionDuration)
{
var transition = _machine.AddAnyStateTransition(state);
SetupComboTransition(transition, transitionDuration);
if (permutation != null)
{
transition.AddCondition(IsEqualTo, (float)permutation.Left, SharedLayerUtils.GestureLeft);
transition.AddCondition(IsEqualTo, (float)permutation.Right, SharedLayerUtils.GestureRight);
}
if (_activityStageName != null && stageValue != null)
{
transition.AddCondition(IsEqualTo, (int)stageValue, _activityStageName);
}
if (permutation == null && stageValue == null)
{
transition.hasExitTime = true;
transition.exitTime = 0f;
}
}
private static void AddAnyStateTransition(AnimationClip newClip, AnimatorController controller, AnimatorControllerLayer layer, int x, int y)
{
AnimatorStateMachine sm = layer.stateMachine;
if (newClip == null)
{
return;
}
AnimatorState state = sm.AddState(newClip.name, new Vector3(sm.anyStatePosition.x + x * 200f, sm.anyStatePosition.y + y * 50f, sm.anyStatePosition.z));
state.motion = newClip;
//把state添加在layer里面
AnimatorStateTransition trans = sm.AddAnyStateTransition(state);
////把默认的时间条件删除
trans.duration = 0.25f;
trans.hasExitTime = false;
controller.AddParameter(new AnimatorControllerParameter {
type = AnimatorControllerParameterType.Bool, defaultBool = false, name = newClip.name
});
trans.AddCondition(AnimatorConditionMode.If, 0f, state.name);
}
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);
if (_createAnimation)
{
var animationClip = AnimUtility.CreateAnimation(_expressionInfo.AnimationsFolder.GetPath(), expName, _dirtyAssets);
toggleState.motion = animationClip;
}
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, 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();
AssetDatabase.Refresh();
}
static void CreateAnimatorWithOutCommon()
{
UnityEngine.Object[] arr = Selection.GetFiltered(typeof(UnityEngine.Object), SelectionMode.TopLevel);
string curPath = AssetDatabase.GetAssetPath(arr[0]);
int start = curPath.LastIndexOf('/') + 1;
string up_path = curPath.Substring(0, start - 1);
string directory = curPath.Substring(start, curPath.Length - start);
string resources_path = up_path + "/Resources";
if (!Directory.Exists(resources_path))
{
Directory.CreateDirectory(resources_path);
}
string animator_name = string.Format("{0}/{1}_animator.controller", resources_path, directory);
// 创建animationController文件
AnimatorController animator = AnimatorController.CreateAnimatorControllerAtPath(animator_name);
AnimatorStateMachine animatorLayer = animator.layers[0].stateMachine;
// 先添加一个默认的空状态
var emptyState = animatorLayer.AddState("empty");
animatorLayer.AddAnyStateTransition(emptyState);
//添加不同的动画
foreach (var path in arr)
{
AddStateTranstion(AssetDatabase.GetAssetPath(path), animatorLayer);
}
AssetDatabase.SaveAssets();
}
/// <summary>
/// 根据一组animation生成一个Animator
/// </summary>
/// <param name="clips"></param>
/// <param name="name"></param>
/// <returns></returns>
private static AnimatorController BuildAnimationController(List <AnimationClip> clips, string name)
{
AnimatorController animatorController = AnimatorController.CreateAnimatorControllerAtPath(AnimationControllerPath + "/" + name + ".controller");
AnimatorControllerLayer layer = animatorController.layers[0];
AnimatorStateMachine stateMachine = layer.stateMachine;
foreach (AnimationClip newClip in clips)
{
var conditionName = newClip.name;
animatorController.AddParameter(conditionName, AnimatorControllerParameterType.Trigger);
AnimatorState state = stateMachine.AddState(newClip.name);
state.motion = newClip;
if (newClip.name.Equals("idle1"))
{
stateMachine.defaultState = state;
}
AnimatorStateTransition trans = stateMachine.AddAnyStateTransition(state);
trans.hasExitTime = false;
trans.AddCondition(AnimatorConditionMode.If, 0, conditionName);
}
AssetDatabase.SaveAssets();
return(animatorController);
}
/// <summary>
/// 菜单方法，遍历文件夹创建Animation Controller
/// </summary>
// [MenuItem("Tools/CreateAnimator")]
// static void CreateAnimationAssets()
// {
// string rootFolder = "Assets/_Game/Models/Character/Animator";
// string common_path = "Assets/_Game/Models/Character/Animator/common";
// string resources_path = string.Format("{0}/Resources", rootFolder);
// if (!Directory.Exists(resources_path))
// {
// Directory.CreateDirectory(resources_path);
// }
//
// // 遍历目录，查找生成controller文件
// var folders = Directory.GetDirectories(rootFolder);
// foreach (var folder in folders)
// {
// DirectoryInfo info = new DirectoryInfo(folder);
// string scene_name = info.Name;
//
// if (scene_name == "Resources")
// continue;
//
// if (scene_name.Contains("withoutcommon"))
// continue;
//
// string animator_name = string.Format("{0}/Resources/{1}_animator.controller", rootFolder, scene_name);
// string search_path = string.Format("{0}/{1}", rootFolder, scene_name);
//
// // 创建animationController文件
// AnimatorController animator = AnimatorController.CreateAnimatorControllerAtPath(animator_name);
//
// AnimatorStateMachine animatorLayer = animator.layers[0].stateMachine;
// // 先添加一个默认的空状态
// var emptyState = animatorLayer.AddState("empty");
// animatorLayer.AddAnyStateTransition(emptyState);
// //添加共同的动画
// AddStateTranstion(common_path, animatorLayer);
// //添加不同的动画
// if (scene_name != "common")
// AddStateTranstion(search_path, animatorLayer);
//
// // 创建预设
// // GameObject go = LoadFbx(folderName);
// // PrefabUtility.CreatePrefab(string.Format("{0}/{1}.prefab", folder, folderName), go);
// // DestroyImmediate(go);
// }
// }
//
// [MenuItem("Tools/CreateAnimator_WithoutCommon")]
// static void CreateAnimationAssetsWithoutCommon()
// {
// string rootFolder = "Assets/_Game/Models/Character/Animator";
// string resources_path = string.Format("{0}/Resources", rootFolder);
// if (!Directory.Exists(resources_path))
// {
// Directory.CreateDirectory(resources_path);
// }
//
// // 遍历目录，查找生成controller文件
// var folders = Directory.GetDirectories(rootFolder);
// foreach (var folder in folders)
// {
// var info = new DirectoryInfo(folder);
// string scene_name = info.Name;
//
// if (scene_name == "Resources")
// continue;
//
// if (!scene_name.Contains("withoutcommon_"))
// continue;
//
// string search_path = string.Format("{0}/{1}", rootFolder, scene_name);
// scene_name = scene_name.Replace("withoutcommon_", "");
// string animator_name = string.Format("{0}/Resources/{1}_animator.controller", rootFolder, scene_name);
// AnimatorController animator = AnimatorController.CreateAnimatorControllerAtPath(animator_name);
//
// AnimatorStateMachine animatorLayer = animator.layers[0].stateMachine;
// // 先添加一个默认的空状态
// var emptyState = animatorLayer.AddState("empty");
// animatorLayer.AddAnyStateTransition(emptyState);
// AddStateTranstion(search_path, animatorLayer);
// }
// }
//
/// <summary>
/// 添加动画状态机状态
/// </summary>
/// <param name="path"></param>
/// <param name="layer"></param>
private static void AddStateTranstion(string path, AnimatorStateMachine animatorLayer)
{
var fileinfos = Directory.GetFiles(path);
foreach (string fileName in fileinfos)
{
if (fileName.Contains(".DS_Store"))
{
continue;
}
var datas = AssetDatabase.LoadAllAssetsAtPath(fileName);
if (datas.Length == 0)
{
continue;
}
// 遍历模型中包含的动画片段，将其加入状态机中
foreach (var data in datas)
{
if (!(data is AnimationClip))
{
continue;
}
var newClip = data as AnimationClip;
if (newClip.name.StartsWith("__"))
{
continue;
}
// 取出动画名字，添加到state里面
var state = animatorLayer.AddState(newClip.name);
state.motion = newClip;
// 把State添加在Layer里面
animatorLayer.AddAnyStateTransition(state);
}
}
}
private static void createAC(string objPath, string objName, Dictionary <string, animCond> conds)
{
int index = objPath.LastIndexOf("/");
string savePath = objPath.Remove(index);
string clipPath = Path.Combine(savePath, "bin/clip");
savePath = Path.Combine(savePath, "bin/ac");
if (!Directory.Exists(savePath))
{
Directory.CreateDirectory(savePath);
}
AnimatorController ac = new AnimatorController();
AnimatorControllerLayer layer = new AnimatorControllerLayer();
layer.name = "Base";
//添加clip
AnimatorStateMachine stateMachine = new AnimatorStateMachine();
string[] files = Directory.GetFiles(clipPath, "*anim");
List <AnimationClip> clips = new List <AnimationClip>();
for (int i = 0; i < files.Length; i++)
{
AnimationClip cp = AssetDatabase.LoadAssetAtPath <AnimationClip>(files[i]);
if (cp != null)
{
clips.Add(cp);
}
}
int startY = 0;
bool isLeft = false;
int startX = 0;
for (int i = 0; i < clips.Count; i++)
{
AnimatorState animState = new AnimatorState();
animState.motion = clips[i] as AnimationClip;
string name = clips[i].name;
animState.name = name;
bool isStand = name == defaultAnim;
startY = isStand ? startY : startY + 1;
if (!isStand)
{
startX = 430;// isLeft ? 430 + 100 : 430 - 100;
isLeft = !isLeft;
}
stateMachine.AddState(animState, isStand ? new Vector2(430, 0) : new Vector2(startX, startY * 100));
if (isStand)
{
stateMachine.defaultState = animState;
}
}
//连线
ChildAnimatorState[] states = stateMachine.states;
for (int i = 0; i < states.Length; i++)
{
ChildAnimatorState currState = states[i];
string name = currState.state.name;
if (conds.ContainsKey(name))
{
animCond cond = conds[name];
string fromStateName = cond.fromState;
if (fromStateName == "Any State")
{
AnimatorStateTransition trans = stateMachine.AddAnyStateTransition(currState.state);
if (!isExitParam(ac, cond.fromCond))
{
ac.AddParameter(cond.fromCond, AnimatorControllerParameterType.Trigger);
}
trans.AddCondition(AnimatorConditionMode.Equals, 0, cond.fromCond);
}
string toStateName = cond.toState;
ChildAnimatorState toState = getState(states, toStateName);
if (toState.state != null && name != defaultAnim)
{
AnimatorStateTransition trans = currState.state.AddTransition(toState.state);
if (cond.toCond == "None")
{
trans.hasExitTime = true;
}
else
{
if (!isExitParam(ac, cond.toCond))
{
ac.AddParameter(cond.toCond, AnimatorControllerParameterType.Trigger);
}
trans.AddCondition(AnimatorConditionMode.Equals, 0, cond.toCond);
}
}
}
}
layer.stateMachine = stateMachine;
ac.AddLayer(layer);
ac.name = objName;
AssetDatabase.CreateAsset(ac, Path.Combine(savePath, objName + ".controller"));
}
static void makeOneEBAniCtrlAndFab(EBAniControls controls)
{
bool isExists = File.Exists(controls.fbxPath);
if (!isExists)
{
Debug.LogWarning(controls.fbxPath + "不存在！！！");
return;
}
string _fold = Path.GetDirectoryName(controls.fbxPath);
string _pathAniCtrl = _fold + Path.DirectorySeparatorChar + controls.name + ".controller";
if (File.Exists(_pathAniCtrl))
{
File.Delete(_pathAniCtrl);
}
//创建animationController文件，保存在Assets路径下
AnimatorController aniController = AnimatorController.CreateAnimatorControllerAtPath(_pathAniCtrl);
int lens = 0;
// =========== layer begin ============
aniController.RemoveLayer(0);
lens = controls.listLayers.Count;
Dictionary <string, AvatarMask> mapAvatarMask = new Dictionary <string, AvatarMask> ();
AvatarMask mask;
for (int i = 0; i < lens; i++)
{
EBAniLayers tmp = controls.listLayers [i];
aniController.AddLayer(tmp.name);
AnimatorControllerLayer aniLayer = aniController.layers [i];
aniLayer.defaultWeight = tmp.weight;
if (string.IsNullOrEmpty(tmp.mask))
{
continue;
}
if (mapAvatarMask.ContainsKey(tmp.mask))
{
mask = mapAvatarMask [tmp.mask];
}
else
{
if (File.Exists(tmp.mask))
{
mask = AssetDatabase.LoadAssetAtPath(tmp.mask, typeof(AvatarMask)) as AvatarMask;
mapAvatarMask [tmp.mask] = mask;
}
else
{
mask = null;
}
}
if (mask != null)
{
aniLayer.avatarMask = mask;
}
}
// =========== parameter begin ============
lens = controls.listParameters.Count;
for (int i = 0; i < lens; i++)
{
EBAniParameters tmp = controls.listParameters [i];
aniController.AddParameter(tmp.name, tmp.getPType);
}
// =========== AnimationClip state begin ============
lens = controls.listState.Count;
string _fabName = Path.GetFileName(controls.fbxPath);
int _indSuffex = _fabName.LastIndexOf(".");
string _fabName2 = _fabName.Substring(0, _indSuffex);
string _suffex = _fabName.Substring(_indSuffex + 1);
if (controls.isHumanid)
{
string _pathClip = "";
for (int i = 0; i < lens; i++)
{
EBAniState _state = controls.listState [i];
if (string.IsNullOrEmpty(_state.actName))
{
continue;
}
_pathClip = _fold + Path.DirectorySeparatorChar + _fabName2 + "@" + _state.actName + "." + _suffex;
if (File.Exists(_pathClip))
{
UnityEngine.Object[] _objs = AssetDatabase.LoadAllAssetsAtPath(_pathClip);
relishipClip(_objs, controls, _state);
}
}
}
else
{
UnityEngine.Object[] _objs = AssetDatabase.LoadAllAssetsAtPath(controls.aniPath);
relishipClip(_objs, controls, null);
}
Dictionary <string, AnimatorState>[] stateDics = new Dictionary <string, AnimatorState> [aniController.layers.Length];
for (int i = 0; i < lens; i++)
{
EBAniState _state = controls.listState [i];
if (_state.aniClip != null || "None".Equals(_state.name))
{
AnimatorControllerLayer aniLayer = aniController.layers [_state.layerIndex]; // .GetLayer (_state.layerIndex);
AnimatorStateMachine aniMachine = aniLayer.stateMachine;
AnimatorState aniState = aniMachine.AddState(_state.name);
if ("None".Equals(_state.name))
{
aniMachine.defaultState = aniState;
}
// BlendTree tree = new BlendTree ();
// tree.blendType = BlendTreeType.SimpleDirectional2D;
// tree.blendParameter = "Action";
// tree.AddChild(_state.aniClip, new Vector2(0.2f, 0.5f));
// tree.name = "_state.name";
aniState.motion = _state.aniClip;
aniState.speed = _state.speed;
if (stateDics [_state.layerIndex] == null)
{
stateDics [_state.layerIndex] = new Dictionary <string, AnimatorState> ();
}
stateDics[_state.layerIndex].Add(_state.name, aniState);
}
}
//需要先将state添加完成后，才能建立 state之间的关系、
//但这里有个问题，就是怎么判断不同layer的state
for (int i = 0, len = controls.listState.Count; i < len; i++)
{
EBAniState _state = controls.listState [i];
AnimatorControllerLayer aniLayer = aniController.layers [_state.layerIndex]; // .GetLayer (_state.layerIndex);
AnimatorStateMachine aniMachine = aniLayer.stateMachine;
if (stateDics [_state.layerIndex] [_state.name] == null)
{
Debug.Log(_state.layerIndex + " " + _state.name + " " + stateDics [_state.layerIndex]);
}
AnimatorState aniState = stateDics[_state.layerIndex] [_state.name];
AnimatorStateTransition startTransition = null;
if (!string.IsNullOrEmpty(_state.enterState))
{
if (_state.enterState.Equals("Entry"))
{
aniMachine.defaultState = aniState;
}
else if (_state.enterState.Equals("Any"))
{
startTransition = aniMachine.AddAnyStateTransition(aniState);
}
else if (stateDics[_state.layerIndex].ContainsKey(_state.enterState))
{
startTransition = stateDics[_state.layerIndex][_state.enterState].AddTransition(aniState);
}
}
if (startTransition != null)
{
startTransition.exitTime = _state.enterExitTime;
startTransition.duration = 1 - _state.enterExitTime;
//过渡用百分比的形式
startTransition.hasFixedDuration = _state.enterHasFixed;
//是否动画播放完才过渡
startTransition.hasExitTime = _state.enterHasExitTime;
startTransition.canTransitionToSelf = false;
for (int j = 0, jlen = _state.enterBrigdes.Count; j < jlen; j++)
{
EBAniBrigdes brigde = _state.enterBrigdes [j];
startTransition.AddCondition(brigde.getTMode, brigde.getTVal, brigde.ebPars.name);
}
}
AnimatorStateTransition endTransition = null;
if (!string.IsNullOrEmpty(_state.endState) && stateDics[_state.layerIndex].ContainsKey(_state.endState))
{
endTransition = aniState.AddTransition(stateDics[_state.layerIndex][_state.endState]);
}
if (endTransition != null)
{
endTransition.exitTime = _state.endExitTime;
endTransition.duration = 1 - _state.endExitTime;
//过渡用百分比的形式
endTransition.hasFixedDuration = _state.endHasFixed;
//是否动画播放完才过渡
endTransition.hasExitTime = _state.endHasExitTime;
endTransition.canTransitionToSelf = false;
for (int j = 0, jlen = _state.endBrigdes.Count; j < jlen; j++)
{
EBAniBrigdes brigde = _state.endBrigdes [j];
endTransition.AddCondition(brigde.getTMode, brigde.getTVal, brigde.ebPars.name);
}
}
}
// =========== 生成prefab 并绑定 animator controller ============
string _foldFab = Path.GetDirectoryName(controls.prefabPath);
if (!Directory.Exists(_foldFab))
{
Directory.CreateDirectory(_foldFab);
}
UnityEngine.GameObject gobjFab;
UnityEngine.GameObject gobjFBX = AssetDatabase.LoadAssetAtPath(controls.fbxPath, typeof(UnityEngine.GameObject)) as GameObject;
if (File.Exists(controls.prefabPath))
{
// File.Delete (controls.prefabPath);
gobjFab = AssetDatabase.LoadAssetAtPath(controls.prefabPath, typeof(UnityEngine.GameObject)) as GameObject;
}
else
{
gobjFab = GameObject.Instantiate(gobjFBX) as GameObject;
}
Animator aniFab = gobjFab.GetComponent <Animator> ();
aniFab.runtimeAnimatorController = aniController;
aniFab.applyRootMotion = false;
UnityEngine.GameObject gobjParent;
if (controls.isAddParent)
{
gobjParent = new GameObject(gobjFab.name);
gobjFab.transform.parent = gobjParent.transform;
}
else
{
gobjParent = gobjFab;
}
if (!File.Exists(controls.prefabPath))
{
PrefabUtility.CreatePrefab(controls.prefabPath, gobjParent);
EditorUtility.SetDirty(gobjParent);
GameObject.DestroyImmediate(gobjParent);
}
}
