static AnimatorController BuildAnimationController(List <AnimationClip> clips, string name, string fileName)
{
AnimatorController animatorController =
UnityEditor.Animations.AnimatorController.CreateAnimatorControllerAtPath(
AnimationControllerPath + "/" + name + "/" + name + ".controller");
AnimatorControllerLayer layer = animatorController.layers[0];
AnimatorStateMachine sm = layer.stateMachine;
animatorController.AddParameter("Attack", AnimatorControllerParameterType.Trigger);
animatorController.AddParameter("Hurt", AnimatorControllerParameterType.Trigger);
Dictionary <string, AnimatorState> animatorStates = new Dictionary <string, AnimatorState>();
foreach (AnimationClip newClip in clips)
{
//AnimatorStateMachine machine = sm.AddStateMachine(newClip.name);
AnimatorState state = sm.AddState(newClip.name);
animatorStates.Add(newClip.name, state);
state.motion = newClip;
//AnimatorStateTransition trans = sm.AddAnyStateTransition(state);
if (newClip.name == "Idle")
{
sm.defaultState = state;
}
}
AssetDatabase.SaveAssets();
return(animatorController);
}
private static int[] GetStateKeys(Animator animator, int layer)
{
List <int> stateKeys = new List <int>();
AnimatorController animatorController = animator.runtimeAnimatorController as AnimatorController;
AnimatorControllerLayer animlayer = animatorController.GetLayer(layer);
StateMachine stateMachine = animlayer.stateMachine;
//StateMachine stateMachine = animatorController.GetLayerStateMachine(layer);
/*List<State> states = stateMachine.statesRecursive;
* foreach (State state in states)
* {
* stateKeys.Add(state.GetUniqueNameHash());
* }*/
for (int i = 0; i < stateMachine.stateCount; i++)
{
stateKeys.Add(stateMachine.GetState(i).uniqueNameHash);
}
return(stateKeys.ToArray());
}
/// <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);
}
}
public void ShowLayersGUI()
{
scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
{
AnimatorControllerLayer[] layers = animatorController.layers;
for (int i = 0; i < layers.Length; i++)
{
AnimatorControllerLayer layer = layers[i];
AnimatorStateMachine machine = layer.stateMachine;
ChildAnimatorState[] states = machine.states;
AnimatorState[] animStates = new AnimatorState[states.Length];
for (int j = 0; j < states.Length; j++)
{
animStates[j] = states[j].state;
}
string key = "Layer " + i;
if (!fieldsFoldout.ContainsKey(key))
{
fieldsFoldout[key] = true;
}
fieldsFoldout[key] = EditorGUI.Foldout(GUILayoutUtility.GetRect(100, 25), fieldsFoldout[key], "Layer " + i + " : " + layer.name);
if (fieldsFoldout[key])
{
ShowStateGUI(animStates);
}
}
}
EditorGUILayout.EndScrollView();
}
private void GenerateActions()
{
ActionsSequencer sequencer = target as ActionsSequencer;
AnimatorController controller = sequencer.controller as AnimatorController;
while (sequencer.transform.childCount > 0)
{
DestroyImmediate(sequencer.transform.GetChild(0).gameObject);
}
AnimatorControllerLayer mainLayer = controller.layers[0];
AnimatorState state = mainLayer.stateMachine.defaultState;
GameObject stateParentGameObject = new GameObject(state.name);
stateParentGameObject.transform.parent = sequencer.transform;
while (state.transitions.Length > 0)
{
AnimatorState subState = state.transitions[0].destinationState;
GameObject subStateGameObject = new GameObject(subState.name);
subStateGameObject.transform.parent = stateParentGameObject.transform;
state = subState;
stateParentGameObject = subStateGameObject;
}
//foreach(ChildAnimatorState childState in mainLayer.stateMachine.states)
//{
// GameObject go = new GameObject(childState.state.name);
// go.transform.parent = sequencer.transform;
//}
}
/// <summary>
/// 动画控制器比较特殊，不能通过序列化得到
/// </summary>
/// <param name="info"></param>
/// <param name="o"></param>
private void AnalyzeObjectReference2(Object o, AssetBundle ab)
{
UnityEditor.Animations.AnimatorController ac = o as UnityEditor.Animations.AnimatorController;
if (ac)
{
#if UNITY_5 || UNITY_5_3_OR_NEWER
foreach (var clip in ac.animationClips)
{
AnalyzeObjectReference(o, ab);
}
#else
List <State> list = new List <State>();
for (int i = 0; i < ac.layerCount; i++)
{
AnimatorControllerLayer layer = ac.GetLayer(i);
list.AddRange(AnimatorStateMachine_StatesRecursive(layer.stateMachine));
}
foreach (State state in list)
{
var clip = state.GetMotion() as AnimationClip;
if (clip)
{
AnalyzeObjectReference(clip, ab);
}
}
#endif
}
}
/// <summary>
/// 动画控制器比较特殊，不能通过序列化得到
/// </summary>
/// <param name="info"></param>
/// <param name="o"></param>
private static void SettingObjectReference2(UnityEngine.Object o)
{
AnimationClip cx = (AnimationClip)AssetDatabase.LoadAssetAtPath("Assets/_Test/C/X.anim", typeof(AnimationClip));
AnimationClip caa = (AnimationClip)AssetDatabase.LoadAssetAtPath("Assets/_Test/aa.anim", typeof(AnimationClip));
UnityEditor.Animations.AnimatorController ac = o as UnityEditor.Animations.AnimatorController;
if (ac)
{
#if UNITY_5 || UNITY_5_3_OR_NEWER
for (int i = 0; i < ac.animationClips.Length; i++)
{
}
#else
List <State> list = new List <State>();
for (int i = 0; i < ac.layerCount; i++)
{
AnimatorControllerLayer layer = ac.GetLayer(i);
list.AddRange(AnimatorStateMachine_StatesRecursive(layer.stateMachine));
}
foreach (State state in list)
{
var clip = state.GetMotion() as AnimationClip;
if (clip == cx)
{
state.SetAnimationClip(caa);
}
}
#endif
}
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
AnimatorControllerExportCollection collection = (AnimatorControllerExportCollection)container.CurrentCollection;
AnimatorControllerParameter[] @params = new AnimatorControllerParameter[Controller.Values.Instance.ValueArray.Count];
for (int i = 0; i < Controller.Values.Instance.ValueArray.Count; i++)
{
@params[i] = new AnimatorControllerParameter(this, i);
}
AnimatorControllerLayer[] layers = new AnimatorControllerLayer[Controller.LayerArray.Count];
for (int i = 0; i < Controller.LayerArray.Count; i++)
{
int stateMachineIndex = Controller.LayerArray[i].Instance.StateMachineIndex;
AnimatorStateMachine stateMachine = collection.StateMachines[stateMachineIndex];
layers[i] = new AnimatorControllerLayer(stateMachine, this, i);
}
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(AnimatorParametersName, @params.ExportYAML(container));
node.Add(AnimatorLayersName, layers.ExportYAML(container));
return(node);
}
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();
}
// ----- ------ Default Clips ----- ------
private static AnimationClip SetAnimationDefault(AnimatorController superAnimator, GameObject gameObject, AvatarMask mask, string folder) {
AnimatorControllerLayer animDefault = new AnimatorControllerLayer {
name = "TEA Defaults",
defaultWeight = 1,
avatarMask = mask,
stateMachine = new AnimatorStateMachine()
};
AnimatorStateMachine stateMachine = animDefault.stateMachine;
AnimationClip def_clip = new AnimationClip {
name = "TEA Defaults"
};
AnimatorState defaultState = stateMachine.AddState("TEA Defaults");
foreach(AnimatorControllerLayer layer in superAnimator.layers) {
SetAnimationDefault(def_clip, layer.stateMachine.states, gameObject);
foreach(ChildAnimatorStateMachine childMachine in layer.stateMachine.stateMachines) {
SetAnimationDefault(def_clip, childMachine.stateMachine.states, gameObject);
}
}
string actionPath = folder + "/" + superAnimator.name + "-def_clip.anim";
AssetDatabase.CreateAsset(def_clip, actionPath);
AnimationClip retClip = AssetDatabase.LoadAssetAtPath<AnimationClip>(actionPath);
defaultState.writeDefaultValues = true;
defaultState.motion = retClip;
AnimatorControllerLayer[] layers = superAnimator.layers;
ArrayUtility.Insert<AnimatorControllerLayer>(ref layers, 0, animDefault);
superAnimator.layers = layers;
return retClip;
}
private static AnimatorControllerLayer DuplicateLayer(AnimatorControllerLayer srcLayer, string dstLayerName, bool firstLayer = false)
{
var newLayer = new AnimatorControllerLayer()
{
avatarMask = srcLayer.avatarMask,
blendingMode = srcLayer.blendingMode,
defaultWeight = srcLayer.defaultWeight,
iKPass = srcLayer.iKPass,
name = dstLayerName,
// 新しく作らないとLayer削除時にコピー元LayerのStateが消える
stateMachine = DuplicateStateMachine(srcLayer.stateMachine),
syncedLayerAffectsTiming = srcLayer.syncedLayerAffectsTiming,
syncedLayerIndex = srcLayer.syncedLayerIndex
};
// 最初のレイヤーはdefaultWeightがどんなものでも自動的にweightが1扱いになっているので
// defaultWeightを1にする
if (firstLayer)
{
newLayer.defaultWeight = 1f;
}
// StateとStateMachineをすべて追加後に遷移を設定
// 親階層へ伸びているっぽい遷移もある?
CopyTransitions(srcLayer.stateMachine, newLayer.stateMachine);
return(newLayer);
}
static void ReflashAnimatorController(string name, string assetPath)
{
string path = "Assets/Resources/Bear/" + name + ".controller";
if (!File.Exists(path))
{
Debug.LogError(name + "没有动画控制文件");
return;
}
AnimatorController animatorController = AssetDatabase.LoadAssetAtPath <AnimatorController> (path);
AnimatorControllerLayer layer = animatorController.layers[0];
AnimatorStateMachine machine = layer.stateMachine;
List <AnimationClip> clips = new List <AnimationClip>();
UnityEngine.Object[] objects = AssetDatabase.LoadAllAssetsAtPath(assetPath);
for (int m = 0; m < objects.Length; m++)
{
if (objects[m].GetType() == typeof(AnimationClip) && !objects[m].name.Contains("Take 001"))
{
AnimationClip clip = (AnimationClip)objects[m];
if (clip != null)
{
clips.Add(clip);
}
}
}
CheckAndRefreshAnimatorController(clips, machine);
}
private void CombineAnimator(AnimatorController superAnimator, AnimatorController animator, AvatarMask mask) {
if(null == animator || null == superAnimator)
return;
foreach(AnimatorControllerParameter param in animator.parameters) {
if(!string.IsNullOrEmpty(param.name) && !HasAnimatorParameter(superAnimator, param.name))
superAnimator.AddParameter(param);
}
foreach(AnimatorControllerLayer layer in animator.layers) {
//Debug.Log($"combining [{superAnimator.name}] with [{animator.name}] layer[{layer.name}]");
AnimatorControllerLayer newLayer = new AnimatorControllerLayer {
avatarMask = null == mask ? layer.avatarMask : mask,
name = layer.name,
blendingMode = layer.blendingMode,
defaultWeight = layer.defaultWeight,
iKPass = layer.iKPass,
stateMachine = layer.stateMachine,
syncedLayerAffectsTiming = layer.syncedLayerAffectsTiming,
syncedLayerIndex = layer.syncedLayerIndex
};
superAnimator.AddLayer(newLayer);
}
//Debug.Log("-----------");
}
public static AnimatorStateMachine FindStateMachine(RuntimeAnimatorController runtimeAnimatorController,
string layerName, params string[] stateMachineNames)
{
AnimatorControllerLayer layer = FindLayer(runtimeAnimatorController, layerName);
return(FindStateMachine(layer, stateMachineNames));
}
/// <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 + "没有挂载动画状态机组件");
}
}
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);
}
static void CreateAnimator(string[] files)
{
string path = new System.Text.StringBuilder().Append(@Application.streamingAssetsPath).Append('/').Append(AppConst.TextDir).Append('/').ToString();
EditorUtil.Init <AnimatorInfo>(path);
EditorUtil.Init <AnimatorTransInfo>(path);
EditorUtil.Init <AnimatorTransfer>(path);
int width = 250;
int height = 50;
for (int i = 0; i < files.Length; i++)
{
string pName = Path.GetFileNameWithoutExtension(files[i]);
AnimatorController controller = AnimatorController.CreateAnimatorControllerAtPath(AppConst.AssetPath + "/Animator/" + pName + ".controller");
AnimatorControllerLayer currLayer = null;
if (controller.layers.Length > 0)
{
currLayer = controller.layers[0];
}
else
{
currLayer = new AnimatorControllerLayer();
currLayer.name = "Base Layer";
controller.AddLayer(currLayer);
}
currLayer.stateMachine.anyStatePosition = new Vector3(0, height * 3, 0);
currLayer.stateMachine.entryPosition = new Vector3(0, height, 0);
currLayer.stateMachine.exitPosition = new Vector3(((int)AnimatState.AnimaState_MAX / 5 + 1) * width, height * 3, 0);
AddAnimatorState(controller, currLayer, width, height, pName);
AddParameters(controller);
AddTransition(currLayer);
}
}
AnimatorStateTransition GetTransition(string nextStateName, AnimatorControllerLayer layer)
{
var animator = target.GetComponent <Animator>();
AnimatorStateMachine stateMachine = layer.stateMachine;
// Find transition from current state
int index = animator.GetLayerIndex(layer.name);
int currentHash = animator.GetCurrentAnimatorStateInfo(index).fullPathHash;
foreach (var childState in stateMachine.states)
{
if (Animator.StringToHash(layer.name + "." + childState.state.name) == currentHash)
{
var transition = System.Array.Find <AnimatorStateTransition>
(childState.state.transitions, p => p.destinationState.name == nextStateName);
if (transition != null)
{
return(transition);
}
}
}
// Find transition from "Any State"
return(System.Array.Find <AnimatorStateTransition>(
stateMachine.anyStateTransitions,
p => p.destinationState.name == nextStateName
));
}
private static void ExportController(AnimatorOverrideController overrideController)
{
string overrideControllerPath = AssetDatabase.GetAssetPath(overrideController);
string controllerPath = AssetDatabase.GetAssetPath(overrideController.runtimeAnimatorController);
string copyControllerPath = overrideControllerPath.Replace(".overrideController", ".controller");
if (AssetDatabase.CopyAsset(controllerPath, copyControllerPath))
{
RuntimeAnimatorController controller = AssetDatabase.LoadAssetAtPath <RuntimeAnimatorController> (copyControllerPath);
AnimatorController animator = controller as AnimatorController;
AnimatorControllerLayer baseLayer = animator.layers[0];
foreach (var clipPair in overrideController.clips)
{
AnimationClip overrideClip = new AnimationClip();
EditorUtility.CopySerialized(clipPair.overrideClip, overrideClip);
overrideClip.hideFlags = HideFlags.None;
AssetDatabase.AddObjectToAsset(overrideClip, controller);
for (int i = 0; i < baseLayer.stateMachine.states.Length; i++)
{
AnimatorState state = baseLayer.stateMachine.states[i].state;
if (state.motion == clipPair.originalClip)
{
state.motion = overrideClip;
}
}
}
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public static AnimatorStateTransition GetTransitionTo(FPlayAnimationEvent animEvt)
{
FAnimationTrack animTrack = (FAnimationTrack)animEvt.Track;
if (animTrack.AnimatorController == null)
{
return(null);
}
AnimatorController controller = (AnimatorController)animTrack.AnimatorController;
AnimatorState animState = null;
AnimatorControllerLayer layer = FindLayer(controller, ((FAnimationTrack)animEvt.Track).LayerName);
if (layer == null)
{
return(null);
}
if (layer.stateMachine.stateMachines.Length == 0)
{
return(null);
}
ChildAnimatorStateMachine fluxSM = layer.stateMachine.stateMachines[0];
AnimatorStateMachine stateMachine = fluxSM.stateMachine;
for (int i = 0; i != stateMachine.states.Length; ++i)
{
if (stateMachine.states[i].state.nameHash == animEvt._stateHash)
{
animState = stateMachine.states[i].state;
break;
}
}
if (animState == null)
{
// Debug.LogError("Couldn't find state " + animEvt._animationClip );
return(null);
}
for (int i = 0; i != stateMachine.states.Length; ++i)
{
AnimatorState state = stateMachine.states[i].state;
AnimatorStateTransition[] transitions = state.transitions;
for (int j = 0; j != transitions.Length; ++j)
{
if (transitions[j].destinationState == animState)
{
return(transitions[j]);
}
}
}
return(null);
}
/// <summary>
/// 创建动画控制器
/// </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);
}
void SetMecanimData()
{
if (gogoAnimator.animator == null)
{
return;
}
animationClipArray = AnimationUtility.GetAnimationClips(gogoAnimator.gameObject);
animationStateList.Clear();
animationStateNameList.Clear();
AnimatorController ac = gogoAnimator.animator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
if (ac != null)
{
for (int i = 0; i < ac.layers.Length; i++)
{
AnimatorControllerLayer layer = ac.layers[i];
for (int j = 0; j < layer.stateMachine.states.Length; j++)
{
animationStateList.Add(layer.stateMachine.states[j]);
animationStateNameList.Add(layer.stateMachine.states[j].state.name);
}
}
}
}
private void InsertLayer(AnimatorController controller, AnimatorControllerLayer layer, int toIndex)
{
var fromIndex = Array.IndexOf(controller.layers.Select(x => x.name).ToArray(), layer.name);
if (fromIndex == -1)
{
controller.AddLayer(layer);
fromIndex = controller.layers.Length - 1;
}
if (fromIndex == toIndex) return;
var layers = controller.layers;
var insert = layers[fromIndex];
var di = fromIndex > toIndex ? 1 : -1;
int i = toIndex;
while(i >= 0 && i < layers.Length)
{
var work = layers[i];
layers[i] = insert;
insert = work;
if (i == fromIndex) break;
i += di;
}
controller.layers = layers;
AssetDatabase.SaveAssets();
}
/// <summary>
/// Creates a Unity sprite animation from the given <see cref="Layer"/> that is a group layer. It grabs all of the children art
/// layers and uses them as the frames of the animation.
/// </summary>
/// <param name="layer">The group <see cref="Layer"/> to use to create the sprite animation.</param>
private static void CreateAnimation(Layer layer)
{
float fps = 30;
string[] args = layer.Name.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string arg in args)
{
if (arg.ContainsIgnoreCase("FPS="))
{
layer.Name = layer.Name.Replace("|" + arg, string.Empty);
string[] fpsArgs = arg.Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
if (!float.TryParse(fpsArgs[1], out fps))
{
Debug.LogError(string.Format("Unable to parse FPS: \"{0}\"", arg));
}
}
}
List <Sprite> frames = new List <Sprite>();
Layer firstChild = layer.Children.First();
SpriteRenderer spriteRenderer = CreateSpriteGameObject(firstChild);
spriteRenderer.name = layer.Name;
foreach (Layer child in layer.Children)
{
frames.Add(CreateSprite(child, layer.Name));
}
spriteRenderer.sprite = frames[0];
#if UNITY_5
// Create Animator Controller with an Animation Clip
UnityEditor.Animations.AnimatorController controller = new UnityEditor.Animations.AnimatorController();
controller.AddLayer("Base Layer");
UnityEditor.Animations.AnimatorControllerLayer controllerLayer = controller.layers[0];
UnityEditor.Animations.AnimatorState state = controllerLayer.stateMachine.AddState(layer.Name);
state.motion = CreateSpriteAnimationClip(layer.Name, frames, fps);
AssetDatabase.CreateAsset(controller, GetRelativePath(currentPath) + "/" + layer.Name + ".controller");
#else // Unity 4
// Create Animator Controller with an Animation Clip
AnimatorController controller = new AnimatorController();
AnimatorControllerLayer controllerLayer = controller.AddLayer("Base Layer");
State state = controllerLayer.stateMachine.AddState(layer.Name);
state.SetAnimationClip(CreateSpriteAnimationClip(layer.Name, frames, fps));
AssetDatabase.CreateAsset(controller, GetRelativePath(currentPath) + "/" + layer.Name + ".controller");
#endif
// Add an Animator and assign it the controller
Animator animator = spriteRenderer.gameObject.AddComponent <Animator>();
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();
}
public override bool OnLayer(AnimatorControllerLayer layer, int lNum)
{
LayerRecord layerRecord = new LayerRecord(
lNum,
layer);
AconDocument.layers.Add(layerRecord); return(true);
}
public override void Initialize(AnimatorControllerLayer layer)
{
EditorAnimationItem dressidle = new EditorAnimationItem_dressidle(resType, layer, sex);
EditorAnimationItem changecloth = new EditorAnimationItem_changecloth(resType, layer, sex);
changecloth.AddTransition(dressidle, AnimatorConditionMode.IfNot, 0f, ActionConst.CHANGE_CLOTH);
dressidle.AddTransition(changecloth, AnimatorConditionMode.If, 0f, ActionConst.CHANGE_CLOTH, false);
}
public AnimatorLayerDefinition(AnimatorDefinition parent, AnimatorControllerLayer controllerLayer)
{
Layer = controllerLayer;
Name = controllerLayer.name;
Parent = parent;
AddStateMachine(controllerLayer.stateMachine);
}
public EditorAnimationItem(ECharacterResType type, AnimatorControllerLayer layer, EnumCharacterType _sex)
{
resType = type;
AnimatorStateMachine baseSm = layer.stateMachine;
state = baseSm.AddState(ClipName);
sex = _sex;
state.motion = motion;
}
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 State AddStateTransition(string path, AnimatorControllerLayer layer, State lastState)
{
UnityEditorInternal.StateMachine sm = layer.stateMachine;
//根据动画文件读取它的AnimationClip对象
AnimationClip newClip = AssetDatabase.LoadAssetAtPath (path, typeof(AnimationClip)) as AnimationClip;
AnimationUtility.SetAnimationType (newClip, ModelImporterAnimationType.Generic);
//取出动画名子 添加到state里面
State state = sm.AddState (newClip.name);
state.SetAnimationClip (newClip, layer);
//把state添加在layer里面
if (lastState ！= null)
{
sm.AddTransition (lastState, state);
}
return state;
}
public BlendTree CreateBlendTree(AnimatorControllerLayer layer)
{
return null;
}
public Motion GetMotion(AnimatorControllerLayer layer)
{
return null;
}
