protected static void DoAnimatorStateMachine(UnityEditor.Animations.AnimatorStateMachine stateMachine, AnimationClip defaultAnimationClip, Dictionary <string, AnimationClip> dic)
{
if (stateMachine == null)
{
return;
}
foreach (ChildAnimatorState childAnimatorState in stateMachine.states)
{
string name = childAnimatorState.state.name;
AnimationClip clip;
if (dic.TryGetValue(name, out clip))
{
childAnimatorState.state.motion = clip;
}
else
{
childAnimatorState.state.motion = defaultAnimationClip;
}
}
foreach (ChildAnimatorStateMachine childAnimatorStateMachine in stateMachine.stateMachines)
{
DoAnimatorStateMachine(childAnimatorStateMachine.stateMachine, defaultAnimationClip, dic);
}
}
private List <AnimationClip> GetClipsFromStatemachine(UnityEditor.Animations.AnimatorStateMachine stateMachine)
{
List <AnimationClip> list = new List <AnimationClip>();
for (int i = 0; i != stateMachine.states.Length; ++i)
{
UnityEditor.Animations.ChildAnimatorState state = stateMachine.states[i];
list.Add(state.state.motion as AnimationClip);
}
for (int i = 0; i != stateMachine.stateMachines.Length; ++i)
{
list.AddRange(GetClipsFromStatemachine(stateMachine.stateMachines[i].stateMachine));
}
var distinctClips = list.Select(q => (AnimationClip)q).Distinct().ToList();
for (int i = 0; i < distinctClips.Count; i++)
{
if (distinctClips[i] && generateAnims.ContainsKey(distinctClips[i].name) == false)
{
generateAnims.Add(distinctClips[i].name, true);
}
}
return(list);
}
private static Dictionary <int, int> GetStatesFromStatemachine(UnityEditor.Animations.AnimatorStateMachine stateMachine)
{
Dictionary <int, int> dict = new Dictionary <int, int>();
for (int i = 0; i != stateMachine.states.Length; ++i)
{
UnityEditor.Animations.ChildAnimatorState state = stateMachine.states[i];
if (state.state.motion is UnityEditor.Animations.BlendTree)
{
//UnityEditor.Animations.BlendTree blendTree = state.state.motion as UnityEditor.Animations.BlendTree;
//ChildMotion[] childMotion = blendTree.children;
//for (int j = 0; j != childMotion.Length; ++j)
//{
// list.Add(childMotion[j].motion as AnimationClip);
//}
}
else if (state.state.motion != null)
{
AnimationClip clip = state.state.motion as AnimationClip;
dict.Add(state.state.nameHash, Animator.StringToHash(clip.name));
}
}
for (int i = 0; i != stateMachine.stateMachines.Length; ++i)
{
Dictionary <int, int> childDict = GetStatesFromStatemachine(stateMachine.stateMachines[i].stateMachine);
foreach (var d in childDict)
{
dict.Add(d.Key, d.Value);
}
}
// var distinctClips = list.Select(q => (AnimationClip)q).Distinct().ToList();
return(dict);
}
private List<AnimationClip> GetClipsFromStatemachine(UnityEditor.Animations.AnimatorStateMachine stateMachine)
{
List<AnimationClip> list = new List<AnimationClip>();
for (int i = 0; i != stateMachine.states.Length; ++i)
{
UnityEditor.Animations.ChildAnimatorState state = stateMachine.states[i];
if (state.state.motion is UnityEditor.Animations.BlendTree)
{
UnityEditor.Animations.BlendTree blendTree = state.state.motion as UnityEditor.Animations.BlendTree;
ChildMotion[] childMotion = blendTree.children;
for(int j = 0; j != childMotion.Length; ++j)
{
list.Add(childMotion[j].motion as AnimationClip);
}
}
else if (state.state.motion != null)
list.Add(state.state.motion as AnimationClip);
}
for (int i = 0; i != stateMachine.stateMachines.Length; ++i)
{
list.AddRange(GetClipsFromStatemachine(stateMachine.stateMachines[i].stateMachine));
}
var distinctClips = list.Select(q => (AnimationClip)q).Distinct().ToList();
for (int i = 0; i < distinctClips.Count; i++)
{
if (distinctClips[i] && generateAnims.ContainsKey(distinctClips[i].name) == false)
generateAnims.Add(distinctClips[i].name, true);
}
return list;
}
public static void PlayMotion(string path, string name, UnityEditor.Animations.AnimatorController ac)
{
UnityEditor.Animations.AnimatorStateMachine sm = ac.layers[0].stateMachine;
for (int i = 0; i < sm.states.Length; i++)
{
sm.RemoveState(sm.states[i].state);
}
addMotionToController(name, ac);
}
private void InitController()
{
if (!this.m_Clip)
{
return;
}
if (!this.m_Clip.legacy && ((this.m_AvatarPreview != null) && (this.m_AvatarPreview.Animator != null)))
{
bool flag = true;
if (this.m_Controller == null)
{
this.m_Controller = new AnimatorController();
this.m_Controller.pushUndoX(false);
this.m_Controller.hideFlags = HideFlags.HideAndDontSave;
this.m_Controller.AddLayer("preview");
this.m_StateMachine = this.m_Controller.layers[0].stateMachine;
this.m_StateMachine.pushUndoX(false);
this.m_StateMachine.hideFlags = HideFlags.HideAndDontSave;
if (this.avatarMask != null)
{
AnimatorControllerLayer[] layers = this.m_Controller.layers;
layers[0].avatarMask = this.avatarMask;
this.m_Controller.layers = layers;
}
flag = false;
}
if (this.m_State == null)
{
this.m_State = this.m_StateMachine.AddState("preview");
this.m_State.pushUndoX(false);
AnimatorControllerLayer[] layers = this.m_Controller.layers;
this.m_State.motion = this.m_Clip;
this.m_Controller.layers = layers;
this.m_State.iKOnFeet = this.m_AvatarPreview.IKOnFeet;
this.m_State.hideFlags = HideFlags.HideAndDontSave;
flag = false;
}
AnimatorController.SetAnimatorController(this.m_AvatarPreview.Animator, this.m_Controller);
if (this.m_AvatarPreview.Animator.GetEffectiveAnimatorControllerX() != this.m_Controller)
{
AnimatorController.SetAnimatorController(this.m_AvatarPreview.Animator, this.m_Controller);
}
if (!flag)
{
this.m_AvatarPreview.Animator.Play(0, 0, 0f);
this.m_AvatarPreview.Animator.Update(0f);
if (this.m_FirstInitialization)
{
this.m_AvatarPreview.ResetPreviewFocus();
this.m_FirstInitialization = false;
}
}
}
}
private void DestroyController()
{
if ((this.m_AvatarPreview != null) && (this.m_AvatarPreview.Animator != null))
{
AnimatorController.SetAnimatorController(this.m_AvatarPreview.Animator, null);
}
UnityEngine.Object.DestroyImmediate(this.m_Controller);
UnityEngine.Object.DestroyImmediate(this.m_State);
this.m_Controller = null;
this.m_StateMachine = null;
this.m_State = null;
}
public void SetPushUndo(UnityEditor.Animations.AnimatorStateMachine asm, bool flag)
{
if (asm == null)
{
return;
}
if (dg_set_pushUndo == null || dg_set_pushUndo.Target != (object)asm)
{
dg_set_pushUndo = (Action <bool>)Delegate.CreateDelegate(typeof(Action <bool>), asm, asm.GetType().GetProperty("pushUndo", BindingFlags.NonPublic | BindingFlags.Instance).GetSetMethod(true));
}
dg_set_pushUndo(flag);
}
List <AnimationClip> GetAnimationLengths()
{
List <AnimationClip> animationClips = new List <AnimationClip>();
#if UNITY_5_1
RuntimeAnimatorController controller = transform.GetComponent <Animator>().runtimeAnimatorController;
for (int i = 0; i < controller.animationClips.Length; i++)
{
AnimationClip clip = new AnimationClip();
// Obviously loading it depends on where/how clip is stored, best case its a resource, worse case you have to search asset database.
string path = AssetDatabase.GetAssetPath(controller.animationClips[i]);
clip = (AnimationClip)AssetDatabase.LoadAssetAtPath(path, typeof(AnimationClip));
//clip = (AnimationClip)Resources.LoadAssetAtPath(_puppet2DPath+"/Animation/" + m.GetState(i).GetMotion().name + ".anim", typeof(AnimationClip));
animationClips.Add(clip);
}
return(animationClips);
#else
RuntimeAnimatorController controller = transform.GetComponent <Animator>().runtimeAnimatorController;
if (controller is UnityEditor.Animations.AnimatorController)
{
UnityEditor.Animations.AnimatorStateMachine m = ((UnityEditor.Animations.AnimatorController)controller).GetLayer(0).stateMachine;
for (int i = 0; i < m.stateCount; i++)
{
AnimationClip clip = new AnimationClip();
// Obviously loading it depends on where/how clip is stored, best case its a resource, worse case you have to search asset database.
if (m.GetState(i).GetMotion())
{
string path = AssetDatabase.GetAssetPath(m.GetState(i).GetMotion());
clip = (AnimationClip)AssetDatabase.LoadAssetAtPath(path, typeof(AnimationClip));
//clip = (AnimationClip)Resources.LoadAssetAtPath(_puppet2DPath+"/Animation/" + m.GetState(i).GetMotion().name + ".anim", typeof(AnimationClip));
animationClips.Add(clip);
}
if (clip)
{
Debug.Log(clip.name + ", length is " + clip.length);
}
}
}
return(animationClips);
#endif
}
void Reset()
{
displayEvents = null;
targetController = null;
targetStateMachine = null;
targetState = null;
targetEvent = null;
selectedLayer = 0;
selectedState = 0;
selectedEvent = 0;
MecanimEventEditorPopup.Destroy();
}
private static void AddStateTransition(string path, UnityEditor.Animations.AnimatorControllerLayer layer, string motionName, Vector3 pos)
{
UnityEditor.Animations.AnimatorStateMachine sm = layer.stateMachine;
Motion motion = AssetDatabase.LoadAssetAtPath(path, typeof(Motion)) as Motion; //根据动画文件读取它的Motion对象
UnityEditor.Animations.AnimatorState state = sm.AddState(motionName, pos); //motion.name
state.motion = motion; //取出动画名子 添加到state里面
UnityEditor.Animations.AnimatorStateTransition trans = sm.AddAnyStateTransition(state); //把state添加在layer里面
trans.hasExitTime = false; //把默认的时间条件删除 //false
//trans.exitTime = 1f; //0.9f
trans.duration = 0f; //默认过渡时间 // 0.1f
trans.canTransitionToSelf = true; //默认true
}
public override string[] GetOptions()
{
List <string> paramList = new List <string>();
if (controller != null)
{
UnityEditor.Animations.AnimatorControllerLayer[] layers = controller.layers;
//List<AnimatorStateInfo> states = new List<AnimatorStateInfo>();
foreach (UnityEditor.Animations.AnimatorControllerLayer layer in layers)
{
UnityEditor.Animations.AnimatorStateMachine sm = layer.stateMachine as UnityEditor.Animations.AnimatorStateMachine;
GetAllStates(sm, layer.name, paramList);
}
}
return(paramList.ToArray());
}
static void FindAllAniInControl(UnityEditor.Animations.AnimatorStateMachine machine, List <AnimationClip> list)
{
for (int i = 0; i < machine.states.Length; i++)
{
var m = machine.states[i].state.motion;
if (list.Contains(m as AnimationClip) == false)
{
list.Add(m as AnimationClip);
}
}
for (int i = 0; i < machine.stateMachines.Length; i++)
{
var m = machine.stateMachines[i].stateMachine;
FindAllAniInControl(m, list);
}
}
public void setLevel(int level, RuntimeAnimatorController animatorController, RuntimeAnimatorController animatorControllerClone)
{
LevelGK levelGK = getLevelGK(level);
if (levelGK == null)
{
return;
}
_flyDistance = levelGK._flyDistance;
_moveSpeed = levelGK._moveSpeed;
_responsive = levelGK._responsive;
_animatorController = animatorController;
_animatorControllerClone = animatorControllerClone;
UnityEditor.Animations.AnimatorController ac = _animatorController as UnityEditor.Animations.AnimatorController;
UnityEditor.Animations.AnimatorStateMachine sm = ac.layers[0].stateMachine;
for (int i = 0; i < sm.states.Length; i++)
{
UnityEditor.Animations.AnimatorState state = sm.states[i].state;
// Debug.Log(string.Format("State: {0}", state.uniqueName));
if (state.name.Equals("save") || state.name.Equals("save center"))
{
state.speed = _responsive;
}
else if (state.name.Equals("move left") || state.name.Equals("move right"))
{
state.speed = _moveSpeed;
}
}
ac = _animatorControllerClone as UnityEditor.Animations.AnimatorController;
sm = ac.layers[0].stateMachine;
for (int i = 0; i < sm.states.Length; i++)
{
UnityEditor.Animations.AnimatorState state = sm.states[i].state;
// Debug.Log(string.Format("State: {0}", state.uniqueName));
if (state.name.Equals("save") || state.name.Equals("save center"))
{
state.speed = _responsive;
}
}
}
public static AnimatorState addNoExistState(AnimatorControllerLayer layer, AnimationClip newClip, bool autoCreate = true)
{
if (newClip == null || layer == null)
{
return(null);
}
UnityEditor.Animations.AnimatorStateMachine sm = layer.stateMachine;
AnimatorState state = getExistState(sm, newClip.name);
if (state == null)
{
state = sm.AddState(newClip.name);
}
state.motion = newClip;
return(state);
}
private void traverseFillStateDict(int depth, string path, UnityEditor.Animations.AnimatorStateMachine stateMachine)
{
foreach (var sta in stateMachine.stateMachines)
{
//Debug.Log("Depth=" + depth + " stateMachines " + sta.stateMachine);
string newPath = path;
newPath = newPath + sta.stateMachine.name + "->";
traverseFillStateDict(depth + 1, newPath, sta.stateMachine);
}
foreach (UnityEditor.Animations.ChildAnimatorState sta in stateMachine.states)
{
if (sta.state != null)
{
stateDict[sta.state.name] = sta.state;
}
}
}
private static UnityEditor.Animations.AnimatorState CreateState(UnityEditor.Animations.AnimatorStateMachine machine, string name, AnimationClip anim, Vector3 pos)
{
foreach (var item in machine.states)
{
if (item.state.name == name)
{
return(item.state);
}
}
UnityEditor.Animations.AnimatorState state = machine.AddState(name);
state.motion = anim;
//state.SetAnimationClip(anim);
var state1 = ArrayUtility.Find <UnityEditor.Animations.ChildAnimatorState>(machine.states, x => x.state == state);
state1.position = pos;
//state.position = pos;
return(state);
}
public AnimatorStateMachine AddStateMachine(string name, Vector3 position)
{
AnimatorStateMachine stateMachine = new AnimatorStateMachine();
stateMachine.hideFlags = HideFlags.HideInHierarchy;
stateMachine.name = MakeUniqueStateMachineName(name);
AddStateMachine(stateMachine, position);
if (AssetDatabase.GetAssetPath(this) != "")
{
AssetDatabase.AddObjectToAsset(stateMachine, AssetDatabase.GetAssetPath(this));
}
undoHandler.DoUndoCreated(stateMachine, "StateMachine Created");
return(stateMachine);
}
/// <summary>
/// <para>Utility function to add an outgoing transition from the source state machine to the destination.</para>
/// </summary>
/// <param name="sourceStateMachine">The source state machine.</param>
/// <param name="destinationStateMachine">The destination state machine.</param>
/// <param name="destinationState">The destination state.</param>
/// <returns>
/// <para>The Animations.AnimatorTransition transition that was created.</para>
/// </returns>
public AnimatorTransition AddStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorStateMachine destinationStateMachine)
{
this.undoHandler.DoUndo((UnityEngine.Object) this, "StateMachine Transition Added");
AnimatorTransition[] machineTransitions = this.GetStateMachineTransitions(sourceStateMachine);
AnimatorTransition animatorTransition = new AnimatorTransition();
if ((bool)((UnityEngine.Object)destinationStateMachine))
{
animatorTransition.destinationStateMachine = destinationStateMachine;
}
if (AssetDatabase.GetAssetPath((UnityEngine.Object) this) != string.Empty)
{
AssetDatabase.AddObjectToAsset((UnityEngine.Object)animatorTransition, AssetDatabase.GetAssetPath((UnityEngine.Object) this));
}
animatorTransition.hideFlags = HideFlags.HideInHierarchy;
ArrayUtility.Add <AnimatorTransition>(ref machineTransitions, animatorTransition);
this.SetStateMachineTransitions(sourceStateMachine, machineTransitions);
return(animatorTransition);
}
public AnimatorTransition AddStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorStateMachine destinationStateMachine)
{
this.undoHandler.DoUndo(this, "StateMachine Transition Added");
AnimatorTransition[] stateMachineTransitions = this.GetStateMachineTransitions(sourceStateMachine);
AnimatorTransition objectToAdd = new AnimatorTransition();
if (destinationStateMachine != null)
{
objectToAdd.destinationStateMachine = destinationStateMachine;
}
if (AssetDatabase.GetAssetPath(this) != string.Empty)
{
AssetDatabase.AddObjectToAsset(objectToAdd, AssetDatabase.GetAssetPath(this));
}
objectToAdd.hideFlags = HideFlags.HideInHierarchy;
ArrayUtility.Add <AnimatorTransition>(ref stateMachineTransitions, objectToAdd);
this.SetStateMachineTransitions(sourceStateMachine, stateMachineTransitions);
return(objectToAdd);
}
public AnimatorTransition AddStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorStateMachine destinationStateMachine)
{
this.undoHandler.DoUndo(this, "StateMachine Transition Added");
AnimatorTransition[] stateMachineTransitions = this.GetStateMachineTransitions(sourceStateMachine);
AnimatorTransition animatorTransition = new AnimatorTransition();
if (destinationStateMachine)
{
animatorTransition.destinationStateMachine = destinationStateMachine;
}
if (AssetDatabase.GetAssetPath(this) != "")
{
AssetDatabase.AddObjectToAsset(animatorTransition, AssetDatabase.GetAssetPath(this));
}
animatorTransition.hideFlags = HideFlags.HideInHierarchy;
ArrayUtility.Add <AnimatorTransition>(ref stateMachineTransitions, animatorTransition);
this.SetStateMachineTransitions(sourceStateMachine, stateMachineTransitions);
return(animatorTransition);
}
public static bool StateMachineRelativePath(AnimatorStateMachine parent, AnimatorStateMachine toFind,
ref List <AnimatorStateMachine> hierarchy)
{
hierarchy.Add(parent);
if (parent == toFind)
{
return(true);
}
var childStateMachines = AnimatorStateMachine.StateMachineCache.GetChildStateMachines(parent);
for (int i = 0; i < childStateMachines.Length; i++)
{
if (StateMachineRelativePath(childStateMachines[i].stateMachine, toFind, ref hierarchy))
{
return(true);
}
}
hierarchy.Remove(parent);
return(false);
}
private void AddAllStates(UnityEditor.Animations.AnimatorStateMachine stateMachine, string substate = "")
{
foreach (var state in stateMachine.states)
{
if (state.state.motion is AnimationClip)
{
animationClips.Add(new AnimationGroup()
{
substate = substate, name = state.state.name, animationClip = state.state.motion as AnimationClip
});
}
else if (state.state.motion is UnityEditor.Animations.BlendTree)
{
AddBlendTreeClips(state.state.motion as UnityEditor.Animations.BlendTree, state.state.name, substate);
}
}
foreach (var childStateMachine in stateMachine.stateMachines)
{
AddAllStates(childStateMachine.stateMachine, childStateMachine.stateMachine.name);
}
}
private static AnimatorState getExistState(UnityEditor.Animations.AnimatorStateMachine stateMachine, string name)
{
AnimatorState state = null;
foreach (ChildAnimatorState animatorState in stateMachine.states)
{
if (animatorState.state.name == name)
{
state = animatorState.state;
break;
}
}
if (state == null)
{
foreach (ChildAnimatorStateMachine childAnimatorStateMachine in stateMachine.stateMachines)
{
state = getExistState(childAnimatorStateMachine.stateMachine, name);
break;
}
}
return(state);
}
private static void AddTransition(UnityEditor.Animations.AnimatorStateMachine machine, UnityEditor.Animations.AnimatorState from, UnityEditor.Animations.AnimatorState to, bool removedef, params object[] conditions)
{
UnityEditor.Animations.AnimatorStateTransition transition = null;
transition = from == null?machine.AddAnyStateTransition(to) : from.AddTransition(to);
//Unity5中默认是没有condition的
//if (removedef) transition.RemoveCondition(0);
transition.offset = 0.0f;
transition.duration = 0.0f;
transition.hasExitTime = false;
for (var i = 0; i < conditions.Length;)
{
if (conditions.Length - i < 2)
{
break;
}
//var cond = transition.AddCondition();
var mode = (UnityEditor.Animations.AnimatorConditionMode)conditions[i++];
var param = conditions[i++].ToString();
//cond.mode = mode;
//cond.parameter = param;
float threshold = 0f;
if (i >= conditions.Length)
{
break;
}
if (mode != UnityEditor.Animations.AnimatorConditionMode.If && mode != UnityEditor.Animations.AnimatorConditionMode.IfNot)
{
threshold = (int)conditions[i++];
}
transition.AddCondition(mode, threshold, param);
}
}
public AnimatorTransition AddStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorStateMachine destinationStateMachine)
{
undoHandler.DoUndo(this, "StateMachine Transition Added");
AnimatorTransition[] transitionsVector = GetStateMachineTransitions(sourceStateMachine);
AnimatorTransition newTransition = new AnimatorTransition();
if (destinationStateMachine)
{
newTransition.destinationStateMachine = destinationStateMachine;
}
if (AssetDatabase.GetAssetPath(this) != "")
{
AssetDatabase.AddObjectToAsset(newTransition, AssetDatabase.GetAssetPath(this));
}
newTransition.hideFlags = HideFlags.HideInHierarchy;
ArrayUtility.Add(ref transitionsVector, newTransition);
SetStateMachineTransitions(sourceStateMachine, transitionsVector);
return(newTransition);
}
private void FillAnimatorState(int depth, UnityEditor.Animations.AnimatorStateMachine stateMachine)
{
foreach (var sta in stateMachine.stateMachines)
{
Debug.Log("Depth=" + depth + " stateMachines " + sta.stateMachine);
FillAnimatorState(depth + 1, sta.stateMachine);
}
foreach (UnityEditor.Animations.ChildAnimatorState sta in stateMachine.states)
{
UnityEditor.Animations.BlendTree blendTree = sta.state.motion as UnityEditor.Animations.BlendTree;
if (blendTree != null)
{
Debug.LogError("Depth=" + depth + " blendTree need to be refined" + sta.state.motion);
int mCount = blendTree.children.Length;
//foreach (var cmotion in blendTree.children)
for (int i = 0; i < mCount; i++)
{
Debug.Log("Blend Clip " + blendTree.children[i].motion);
Vector2 position = blendTree.children[i].position;
blendTree.AddChild(emptyClip, position);
}
for (int i = 0; i < mCount; i++)
{
blendTree.RemoveChild(0);
}
sta.state.motion = blendTree;
}
else
{
Debug.Log("Depth=" + depth + " Clip " + sta.state.motion);
sta.state.motion = emptyClip;
}
}
}
private static List <AnimClipData> GetClipsFromStatemachine(UnityEditor.Animations.AnimatorStateMachine stateMachine)
{
List <AnimClipData> list = new List <AnimClipData>();
for (int i = 0; i != stateMachine.states.Length; ++i)
{
UnityEditor.Animations.ChildAnimatorState state = stateMachine.states[i];
if (state.state.motion is UnityEditor.Animations.BlendTree)
{
UnityEditor.Animations.BlendTree blendTree = state.state.motion as UnityEditor.Animations.BlendTree;
ChildMotion[] childMotion = blendTree.children;
for (int j = 0; j != childMotion.Length; ++j)
{
AnimClipData clipData = new AnimClipData();
clipData.clip = childMotion[j].motion as AnimationClip;
clipData.speed = 1;
list.Add(clipData);
}
}
else if (state.state.motion != null)
{
AnimClipData clipData = new AnimClipData();
clipData.clip = state.state.motion as AnimationClip;
clipData.speed = state.state.speed;
list.Add(clipData);
}
}
for (int i = 0; i != stateMachine.stateMachines.Length; ++i)
{
list.AddRange(GetClipsFromStatemachine(stateMachine.stateMachines[i].stateMachine));
}
list = list.Select(q => (AnimClipData)q).Distinct().ToList();
return(list);
}
public static bool StateMachineRelativePath(AnimatorStateMachine parent, AnimatorStateMachine toFind, ref List <AnimatorStateMachine> hierarchy)
{
hierarchy.Add(parent);
bool result;
if (parent == toFind)
{
result = true;
}
else
{
for (int i = 0; i < parent.stateMachines.Length; i++)
{
if (MecanimUtilities.StateMachineRelativePath(parent.stateMachines[i].stateMachine, toFind, ref hierarchy))
{
result = true;
return(result);
}
}
hierarchy.Remove(parent);
result = false;
}
return(result);
}
void CheckResources()
{
ActiveTextures.Clear();
ActiveMaterials.Clear();
ActiveMeshDetails.Clear();
Renderer[] renderers = FindObjects <Renderer>();
//Debug.Log("Total renderers "+renderers.Length);
foreach (Renderer renderer in renderers)
{
//Debug.Log("Renderer is "+renderer.name);
foreach (Material material in renderer.sharedMaterials)
{
MaterialDetails tMaterialDetails = FindMaterialDetails(material);
if (tMaterialDetails == null)
{
tMaterialDetails = new MaterialDetails();
tMaterialDetails.material = material;
ActiveMaterials.Add(tMaterialDetails);
}
tMaterialDetails.FoundInRenderers.Add(renderer);
}
if (renderer is SpriteRenderer)
{
SpriteRenderer tSpriteRenderer = (SpriteRenderer)renderer;
if (tSpriteRenderer.sprite != null)
{
var tSpriteTextureDetail = GetTextureDetail(tSpriteRenderer.sprite.texture, renderer);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
}
}
if (IncludeGuiElements)
{
Graphic[] graphics = FindObjects <Graphic>();
foreach (Graphic graphic in graphics)
{
if (graphic.mainTexture)
{
var tSpriteTextureDetail = GetTextureDetail(graphic.mainTexture, graphic);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
if (graphic.materialForRendering)
{
MaterialDetails tMaterialDetails = FindMaterialDetails(graphic.materialForRendering);
if (tMaterialDetails == null)
{
tMaterialDetails = new MaterialDetails();
tMaterialDetails.material = graphic.materialForRendering;
ActiveMaterials.Add(tMaterialDetails);
}
tMaterialDetails.FoundInGraphics.Add(graphic);
}
}
}
foreach (MaterialDetails tMaterialDetails in ActiveMaterials)
{
Material tMaterial = tMaterialDetails.material;
if (tMaterial != null)
{
var dependencies = EditorUtility.CollectDependencies(new UnityEngine.Object[] { tMaterial });
foreach (Object obj in dependencies)
{
if (obj is Texture)
{
Texture tTexture = obj as Texture;
var tTextureDetail = GetTextureDetail(tTexture, tMaterial, tMaterialDetails);
ActiveTextures.Add(tTextureDetail);
}
}
//if the texture was downloaded, it won't be included in the editor dependencies
if (tMaterial.mainTexture != null && !dependencies.Contains(tMaterial.mainTexture))
{
var tTextureDetail = GetTextureDetail(tMaterial.mainTexture, tMaterial, tMaterialDetails);
ActiveTextures.Add(tTextureDetail);
}
}
}
MeshFilter[] meshFilters = FindObjects <MeshFilter>();
foreach (MeshFilter tMeshFilter in meshFilters)
{
Mesh tMesh = tMeshFilter.sharedMesh;
if (tMesh != null)
{
MeshDetails tMeshDetails = FindMeshDetails(tMesh);
if (tMeshDetails == null)
{
tMeshDetails = new MeshDetails();
tMeshDetails.mesh = tMesh;
ActiveMeshDetails.Add(tMeshDetails);
}
tMeshDetails.FoundInMeshFilters.Add(tMeshFilter);
}
}
SkinnedMeshRenderer[] skinnedMeshRenderers = FindObjects <SkinnedMeshRenderer>();
foreach (SkinnedMeshRenderer tSkinnedMeshRenderer in skinnedMeshRenderers)
{
Mesh tMesh = tSkinnedMeshRenderer.sharedMesh;
if (tMesh != null)
{
MeshDetails tMeshDetails = FindMeshDetails(tMesh);
if (tMeshDetails == null)
{
tMeshDetails = new MeshDetails();
tMeshDetails.mesh = tMesh;
ActiveMeshDetails.Add(tMeshDetails);
}
tMeshDetails.FoundInSkinnedMeshRenderer.Add(tSkinnedMeshRenderer);
}
}
if (IncludeSpriteAnimations)
{
Animator[] animators = FindObjects <Animator>();
foreach (Animator anim in animators)
{
#if UNITY_4_6 || UNITY_4_5 || UNITY_4_4 || UNITY_4_3
UnityEditorInternal.AnimatorController ac = anim.runtimeAnimatorController as UnityEditorInternal.AnimatorController;
#elif UNITY_5
UnityEditor.Animations.AnimatorController ac = anim.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
#endif
//Skip animators without layers, this can happen if they don't have an animator controller.
if (!ac || ac.layers == null || ac.layers.Length == 0)
{
continue;
}
for (int x = 0; x < anim.layerCount; x++)
{
#if UNITY_4_6 || UNITY_4_5 || UNITY_4_4 || UNITY_4_3
UnityEditorInternal.StateMachine sm = ac.GetLayer(x).stateMachine;
int cnt = sm.stateCount;
#elif UNITY_5
UnityEditor.Animations.AnimatorStateMachine sm = ac.layers[x].stateMachine;
int cnt = sm.states.Length;
#endif
for (int i = 0; i < cnt; i++)
{
#if UNITY_4_6 || UNITY_4_5 || UNITY_4_4 || UNITY_4_3
UnityEditorInternal.State state = sm.GetState(i);
Motion m = state.GetMotion();
#elif UNITY_5
UnityEditor.Animations.AnimatorState state = sm.states[i].state;
Motion m = state.motion;
#endif
if (m != null)
{
AnimationClip clip = m as AnimationClip;
EditorCurveBinding[] ecbs = AnimationUtility.GetObjectReferenceCurveBindings(clip);
foreach (EditorCurveBinding ecb in ecbs)
{
if (ecb.propertyName == "m_Sprite")
{
foreach (ObjectReferenceKeyframe keyframe in AnimationUtility.GetObjectReferenceCurve(clip, ecb))
{
Sprite tSprite = keyframe.value as Sprite;
if (tSprite != null)
{
var tTextureDetail = GetTextureDetail(tSprite.texture, anim);
if (!ActiveTextures.Contains(tTextureDetail))
{
ActiveTextures.Add(tTextureDetail);
}
}
}
}
}
}
}
}
}
}
if (IncludeScriptReferences)
{
MonoBehaviour[] scripts = FindObjects <MonoBehaviour>();
foreach (MonoBehaviour script in scripts)
{
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; // only public non-static fields are bound to by Unity.
FieldInfo[] fields = script.GetType().GetFields(flags);
foreach (FieldInfo field in fields)
{
System.Type fieldType = field.FieldType;
if (fieldType == typeof(Sprite))
{
Sprite tSprite = field.GetValue(script) as Sprite;
if (tSprite != null)
{
var tSpriteTextureDetail = GetTextureDetail(tSprite.texture, script);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
}
}
}
}
TotalTextureMemory = 0;
foreach (TextureDetails tTextureDetails in ActiveTextures)
{
TotalTextureMemory += tTextureDetails.memSizeKB;
}
TotalMeshVertices = 0;
foreach (MeshDetails tMeshDetails in ActiveMeshDetails)
{
TotalMeshVertices += tMeshDetails.mesh.vertexCount;
}
// Sort by size, descending
ActiveTextures.Sort(delegate(TextureDetails details1, TextureDetails details2) { return(details2.memSizeKB - details1.memSizeKB); });
ActiveMeshDetails.Sort(delegate(MeshDetails details1, MeshDetails details2) { return(details2.mesh.vertexCount - details1.mesh.vertexCount); });
collectedInPlayingMode = Application.isPlaying;
}
