IEnumerator CollectAtlasInfo(AssetTreeModel <SpriteTrackData> dataModel, Dictionary <Sprite, HashSet <Object> > allUsed, Dictionary <Sprite, SimpleSpriteInfo> sprCache)
{
var displayRoot = CreateDisplayRoot("Atlas");
displayRoot.ShowMode = SpriteShowMode.Atlas;
dataModel.Add(ref displayRoot);
dataModel.AddChild(dataModel.Root.Id, displayRoot.Id);
Dictionary <string, Dictionary <Sprite, HashSet <Object> > > dict = GetAtlasInfo(allUsed, sprCache);
int i = 0;
foreach (var pair in dict)
{
SpriteTrackData sprData = new SpriteTrackData();
sprData.ShowMode = SpriteShowMode.Atlas;
sprData.Id = AssetTreeManager.mIns.GetUniqueId();
sprData.DisplayName = pair.Key;
sprData.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.Image);
dataModel.Add(ref sprData);
dataModel.AddChild(ref displayRoot, ref sprData);
BuildAtlasSprData(dataModel, pair.Value, sprCache, ref sprData);
yield return(DisplayProgressBar("Parse Atlas", "Parsing " + pair.Key, (float)i / dict.Count));
i++;
}
}
void BuildAtlasSprData(AssetTreeModel <SpriteTrackData> dataModel, Dictionary <Sprite, HashSet <Object> > dict, Dictionary <Sprite, SimpleSpriteInfo> sprCache, ref SpriteTrackData displayRoot)
{
foreach (var pair in dict)
{
SpriteTrackData rootData = new SpriteTrackData();
rootData.ShowMode = SpriteShowMode.Atlas;
rootData.Id = AssetTreeManager.mIns.GetUniqueId();
rootData.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.Sprite);
rootData.DisplayName = pair.Key.name;
rootData.AtlasData.RefData.Target = pair.Key;
rootData.AtlasData.RefData.InstanceId = pair.Key.GetInstanceID();
rootData.AtlasData.SprData = GetSpriteData(sprCache, pair.Key);
dataModel.Add(ref rootData);
foreach (var refTarget in pair.Value)
{
SpriteTrackData refData = BuildData(pair.Key, refTarget, SpriteShowMode.Atlas, sprCache);
dataModel.Add(ref refData);
dataModel.AddChild(ref rootData, ref refData);
}
dataModel.AddChild(ref displayRoot, ref rootData);
}
}
SpriteTrackData CreateDisplayRoot(string name)
{
SpriteTrackData rootData = new SpriteTrackData();
rootData.Id = AssetTreeManager.mIns.GetUniqueId();
rootData.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.Folder);
rootData.DisplayName = name;
return(rootData);
}
SpriteTrackData BuildData(Sprite key, Object reference, SpriteShowMode mode, Dictionary <Sprite, SimpleSpriteInfo> sprCache)
{
SpriteTrackData data = new SpriteTrackData();
data.ShowMode = mode;
data.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.Sprite);
data.Id = AssetTreeManager.mIns.GetUniqueId();
data.FilePath = AssetDatabase.GetAssetPath(key);
data.DisplayName = key ? key.name : "Null Sprite";
if (mode == SpriteShowMode.Scene)
{
data.SceneData.SprData = GetSpriteData(sprCache, key);
data.SceneData.CsReferences = reference as MonoBehaviour;
if (data.SceneData.CsReferences)
{
data.SceneData.Path = GetPath(data.SceneData.CsReferences.gameObject);
}
data.SceneData.InstanceId = reference.GetInstanceID();
data.SceneData.MemSize = AssetBundleEditorHelper.ConvertSize(Profiler.GetRuntimeMemorySizeLong(reference));
}
else if (mode == SpriteShowMode.Prefabs)
{
data.GameObjectData.SprData = GetSpriteData(sprCache, key);
data.GameObjectData.GoData = GetGoData(reference);
}
else if (mode == SpriteShowMode.Atlas)
{
if (reference is GameObject)
{
data.DisplayName = reference ? reference.name : "Null";
data.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.GameObject);
data.AtlasData.RefData.Path = GetPath(((GameObject)reference));
}
else if (reference is MonoBehaviour)
{
data.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.Cs);
data.DisplayName = reference ? MonoScript.FromMonoBehaviour(reference as MonoBehaviour).name : "Null";
data.AtlasData.RefData.Path = AssetDatabase.GetAssetPath(MonoScript.FromMonoBehaviour((MonoBehaviour)reference));
}
else
{
data.DisplayName = reference ? reference.name : "Null";
data.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.Folder);
}
data.AtlasData.RefData.Target = reference;
data.AtlasData.RefData.InstanceId = reference.GetInstanceID();
data.AtlasData.RefData.MemSize = AssetBundleEditorHelper.ConvertSize(Profiler.GetRuntimeMemorySizeLong(reference));
data.AtlasData.SprData = GetSpriteData(sprCache, key);
}
return(data);
}
IEnumerator CollectPrefabsInfo(AssetTreeModel <SpriteTrackData> dataModel, Dictionary <Sprite, HashSet <Object> > allUsed, Dictionary <Sprite, SimpleSpriteInfo> sprCache)
{
var displayRoot = CreateDisplayRoot("Prefabs");
displayRoot.ShowMode = SpriteShowMode.Prefabs;
dataModel.Add(ref displayRoot);
dataModel.AddChild(dataModel.Root.Id, displayRoot.Id);
yield return(DisplayProgressBar("Parse Prefab", "Start Parse ", 0));
if (EditorContexts.mIns.GuiContext.SelectPaths != null && EditorContexts.mIns.GuiContext.SelectPaths.Count > 0)
{
List <string> selects = ListPool <string> .Get();
foreach (var pair in EditorContexts.mIns.GuiContext.SelectPaths)
{
if (pair.Value)
{
selects.Add(pair.Key);
}
}
if (selects.Count == 0)
{
ListPool <string> .Release(selects);
}
else
{
string[] guids = AssetDatabase.FindAssets("t:GameObject", selects.ToArray());
ListPool <string> .Release(selects);
yield return(DisplayProgressBar("Parse Prefab", "Start Parse Select Path", 0.05f));
HashSet <string> pathHashSet = new HashSet <string>();
for (int i = 0; i < guids.Length; i++)
{
string assetpath = AssetDatabase.GUIDToAssetPath(guids[i]);
pathHashSet.Add(assetpath);
yield return(DisplayProgressBar("Parse Prefab", "Add Path " + assetpath, (float)i / guids.Length));
}
int m = 0;
foreach (var assetpath in pathHashSet)
{
SpriteTrackData sprData = BuildGoData(dataModel, allUsed, sprCache, assetpath);
dataModel.Add(ref sprData);
dataModel.AddChild(ref displayRoot, ref sprData);
yield return(DisplayProgressBar("Parse Prefab", "Parse " + assetpath, (float)m / guids.Length));
m++;
}
}
}
}
public void SelectionChanged(IList <TreeViewItem> selectedIds)
{
if (selectedIds.Count > 0)
{
List <int> list = new List <int>();
foreach (var item in selectedIds)
{
var assetitem = item as AssetTreeItem <SpriteTrackData>;
if (assetitem != null)
{
SpriteTrackData data = assetitem.GetData();
if (data.ShowMode == SpriteShowMode.Scene)
{
if (data.SceneData.CsReferences != null)
{
list.Add(data.SceneData.InstanceId);
}
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
if (data.GameObjectData.GoData.Go != null)
{
list.Add(data.GameObjectData.GoData.InstanceId);
}
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
if (data.AtlasData.RefData.Target != null)
{
list.Add(data.AtlasData.RefData.InstanceId);
}
}
}
}
if (list.Count > 0)
{
EditorGUIUtility.PingObject(list[0]);
Selection.instanceIDs = list.ToArray();
}
else
{
Selection.instanceIDs = new int[0];
}
}
}
public IEnumerator ReLoad()
{
var dataModel = AssetTreeManager.mIns.GetModel <SpriteTrackData>();
//create root
SpriteTrackData rootData = new SpriteTrackData();
rootData.Id = AssetTreeManager.mIns.GetUniqueId();
dataModel.Root = rootData;
dataModel.Add(ref rootData);
BuildUseablePaths();
Dictionary <Sprite, SimpleSpriteInfo> sprCache = new Dictionary <Sprite, SimpleSpriteInfo>();
Dictionary <Sprite, HashSet <Object> > allUsed = new Dictionary <Sprite, HashSet <Object> >();
yield return(CollectSceneInfo(dataModel, allUsed, sprCache));
yield return(CollectPrefabsInfo(dataModel, allUsed, sprCache));
yield return(CollectAtlasInfo(dataModel, allUsed, sprCache));
Inited = true;
}
public bool CellGui(TreeViewItem item, ref AssetRowGuiArgs args)
{
if (item is AssetTreeItem <SpriteTrackData> )
{
AssetTreeItem <SpriteTrackData> trackItem = item as AssetTreeItem <SpriteTrackData>;
GUI.skin.label.richText = true;
SpriteTopMenu topMenu = (SpriteTopMenu)args.Column;
SpriteTrackData data = trackItem.GetData();
if (topMenu == SpriteTopMenu.Name)
{
return(false);
}
else if (topMenu == SpriteTopMenu.Type)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
GUI.Label(args.CellRect, "Scene");
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
GUI.Label(args.CellRect, "GameObject");
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
GUI.Label(args.CellRect, "Atlas");
}
}
else if (topMenu == SpriteTopMenu.BundleName)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
GUI.Label(args.CellRect, data.SceneData.SprData.BundleName);
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
GUI.Label(args.CellRect, data.GameObjectData.SprData.BundleName);
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
GUI.Label(args.CellRect, data.AtlasData.SprData.BundleName);
}
}
else if (topMenu == SpriteTopMenu.AtlasName)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
if (item.depth == 2)
{
if (string.IsNullOrEmpty(data.SceneData.SprData.PackingTag) == false)
{
string newval = GUI.TextField(args.CellRect, data.SceneData.SprData.PackingTag);
if (CheckTag(newval, data.SceneData.SprData.PackingTag))
{
data.SceneData.SprData.Importer.spritePackingTag = newval;
data.SceneData.SprData.PackingTag = newval;
data.SceneData.SprData.Importer.SaveAndReimport();
trackItem.SetData(data);
}
}
}
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
if (item.depth == 3)
{
if (string.IsNullOrEmpty(data.GameObjectData.SprData.PackingTag) == false)
{
string newval = GUI.TextField(args.CellRect, data.GameObjectData.SprData.PackingTag);
if (CheckTag(newval, data.GameObjectData.SprData.PackingTag))
{
data.GameObjectData.SprData.Importer.spritePackingTag = newval;
data.GameObjectData.SprData.PackingTag = newval;
data.GameObjectData.SprData.Importer.SaveAndReimport();
trackItem.SetData(data);
}
}
}
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
if (item.depth == 2)
{
if (string.IsNullOrEmpty(data.AtlasData.SprData.PackingTag) == false)
{
string newval = GUI.TextField(args.CellRect, data.AtlasData.SprData.PackingTag);
if (CheckTag(newval, data.AtlasData.SprData.PackingTag))
{
data.AtlasData.SprData.Importer.spritePackingTag = newval;
data.AtlasData.SprData.PackingTag = newval;
data.AtlasData.SprData.Importer.SaveAndReimport();
trackItem.SetData(data);
}
}
}
}
}
else if (topMenu == SpriteTopMenu.UsedCount)
{
if (item.depth > 0 && (data.ShowMode == SpriteShowMode.Scene || data.ShowMode == SpriteShowMode.Prefabs))
{
GUI.Label(args.CellRect, data.UsedRefCount.ToString());
}
}
else if (topMenu == SpriteTopMenu.MemSize)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
if (item.depth == 2)
{
GUI.Label(args.CellRect, "Spr:" + data.SceneData.SprData.MemSize + " Tex:" + data.SceneData.SprData.TexMemSize);
}
else if (item.depth > 0)
{
GUI.Label(args.CellRect, "Script:" + data.SceneData.MemSize);
}
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
if (item.depth == 3)
{
GUI.Label(args.CellRect, "Spr:" + data.GameObjectData.SprData.MemSize + " Tex:" + data.GameObjectData.SprData.TexMemSize);
}
else if (item.depth > 0)
{
GUI.Label(args.CellRect, "Go:" + data.GameObjectData.GoData.MemSize);
}
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
if (item.depth == 2)
{
GUI.Label(args.CellRect, "Spr:" + data.AtlasData.SprData.MemSize + " Tex:" + data.AtlasData.SprData.TexMemSize);
}
else if (item.depth > 1)
{
GUI.Label(args.CellRect, "Ref:" + data.AtlasData.RefData.MemSize);
}
}
}
else if (topMenu == SpriteTopMenu.Size)
{
if (data.ShowMode == SpriteShowMode.Atlas)
{
if (data.AtlasData.SprData.Sprite != null)
{
GUI.Label(args.CellRect, data.AtlasData.SprData.TexSize.ToString());
}
}
}
else if (topMenu == SpriteTopMenu.Info)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
if (item.depth == 1)
{
if (data.SceneData.CsReferences)
{
GUI.Label(args.CellRect, string.Format("Type :{0} Path:{1} ",
AssetBundleEditorHelper.GetColorText("{0}", Color.black, data.SceneData.CsReferences),
AssetBundleEditorHelper.GetColorText("{0}", Color.white, data.SceneData.Path)
));
}
}
else if (item.depth == 2)
{
if (data.SceneData.SprData.Sprite)
{
GUI.Label(args.CellRect, GetSprInfo(ref data.SceneData.SprData));
}
}
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
if (item.depth == 1)
{
GUI.Label(args.CellRect, string.Format("AssetPath :{0} Path:{1} PrefabType:{2}",
AssetBundleEditorHelper.GetColorText("{0}", Color.black, data.GameObjectData.GoData.AssetPath),
AssetBundleEditorHelper.GetColorText("{0}", Color.white, data.GameObjectData.GoData.Path),
AssetBundleEditorHelper.GetColorText("{0}", Color.yellow, data.GameObjectData.GoData.PrefabType)));
}
else if (item.depth == 2)
{
GUI.Label(args.CellRect, GetSprInfo(ref data.GameObjectData.SprData));
}
else if (item.depth == 3)
{
if (data.GameObjectData.SprData.Sprite)
{
GUI.Label(args.CellRect, GetSprInfo(ref data.GameObjectData.SprData));
}
}
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
if (item.depth == 2)
{
if (data.AtlasData.SprData.Sprite)
{
GUI.Label(args.CellRect, GetSprInfo(ref data.AtlasData.SprData));
}
}
else if (item.depth == 3)
{
if (data.AtlasData.RefData.Target)
{
GUI.Label(args.CellRect, string.Format("{0} Path:{1}",
AssetBundleEditorHelper.GetColorText("{0}", Color.black, data.AtlasData.RefData.Target),
AssetBundleEditorHelper.GetColorText("{0}", Color.white, data.AtlasData.RefData.Path)));
}
}
}
}
GUI.skin.label.richText = false;
}
else
{
return(false);
}
return(true);
}
SpriteTrackData BuildGoData(AssetTreeModel <SpriteTrackData> dataModel, Dictionary <Sprite, HashSet <Object> > allUsed, Dictionary <Sprite, SimpleSpriteInfo> sprCache, string assetpath)
{
GameObject gameObject = AssetDatabase.LoadAssetAtPath <GameObject>(assetpath);
if (gameObject)
{
HashSet <string> allHashSet = HashSetPool <string> .Get();
SpriteTrackData data = new SpriteTrackData();
data.ShowMode = SpriteShowMode.Prefabs;
data.Id = AssetTreeManager.mIns.GetUniqueId();
data.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.GameObject);
data.DisplayName = Path.GetFileNameWithoutExtension(assetpath);
data.GameObjectData.GoData = GetGoData(gameObject);
string bundleName = "";
AssetImporter importer = AssetImporter.GetAtPath(assetpath);
if (importer)
{
bundleName = importer.assetBundleName;
}
data.GameObjectData.SprData.BundleName = bundleName;
data.GameObjectData.SprData.AssetPath = assetpath;
var allScripts = gameObject.GetComponentsInChildren <MonoBehaviour>(true);
Dictionary <Sprite, HashSet <Object> > allRecords = new Dictionary <Sprite, HashSet <Object> >();
foreach (MonoBehaviour script in allScripts)
{
CollectSprite(script, allRecords);
}
foreach (var pair in allRecords)
{
HashSet <Object> hashset;
if (allUsed.TryGetValue(pair.Key, out hashset))
{
foreach (var subdata in pair.Value)
{
hashset.Add(subdata);
}
}
else
{
allUsed[pair.Key] = pair.Value;//new HashSet<Object>(pair.Value);
}
}
HashSet <string> atlasHashset = HashSetPool <string> .Get();
Dictionary <Object, List <Sprite> > sprRefDictionary = Convert(allRecords);
foreach (var pair in sprRefDictionary)
{
atlasHashset.Clear();
SpriteTrackData sprData = new SpriteTrackData();
sprData.ShowMode = SpriteShowMode.Prefabs;
sprData.Id = AssetTreeManager.mIns.GetUniqueId();
sprData.DisplayName = MonoScript.FromMonoBehaviour(pair.Key as MonoBehaviour).name;
sprData.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.Cs);
sprData.GameObjectData.GoData = GetGoData(pair.Key);
sprData.GameObjectData.SprData.BundleName = bundleName;
sprData.GameObjectData.SprData.AssetPath = AssetDatabase.GetAssetPath(pair.Key);
dataModel.Add(ref sprData);
foreach (var refsprite in pair.Value)
{
SpriteTrackData refData = BuildData(refsprite, pair.Key, SpriteShowMode.Prefabs, sprCache);
refData.UsedRefCount = 1;
dataModel.Add(ref refData);
dataModel.AddChild(ref sprData, ref refData);
atlasHashset.Add(refData.GameObjectData.SprData.PackingTag);
allHashSet.Add(refData.GameObjectData.SprData.PackingTag);
}
sprData.UsedRefCount = atlasHashset.Count;
//refresh
dataModel.Add(ref sprData);
//
dataModel.AddChild(ref data, ref sprData);
}
data.UsedRefCount = allHashSet.Count;
//refresh
dataModel.Add(ref data);
HashSetPool <string> .Release(atlasHashset);
HashSetPool <string> .Release(allHashSet);
return(data);
}
else
{
SpriteTrackData data = new SpriteTrackData();
data.ShowMode = SpriteShowMode.Prefabs;
data.Id = AssetTreeManager.mIns.GetUniqueId();
data.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.Prefab);
data.DisplayName = "Load Failed";
return(data);
}
}
IEnumerator CollectSceneInfo(AssetTreeModel <SpriteTrackData> dataModel, Dictionary <Sprite, HashSet <Object> > allUsed, Dictionary <Sprite, SimpleSpriteInfo> sprCache)
{
var displayRoot = CreateDisplayRoot("Scene");
displayRoot.ShowMode = SpriteShowMode.Scene;
dataModel.Add(ref displayRoot);
dataModel.AddChild(dataModel.Root.Id, displayRoot.Id);
var allScripts = GameObject.FindObjectsOfType <MonoBehaviour>();
Dictionary <Sprite, HashSet <Object> > allRecords = new Dictionary <Sprite, HashSet <Object> >();
int i = 0;
foreach (MonoBehaviour script in allScripts)
{
CollectSprite(script, allRecords);
yield return(DisplayProgressBar("Parse Scene", "Parsing script " + script.name, (float)i / allScripts.Length));
i++;
}
foreach (var pair in allRecords)
{
allUsed[pair.Key] = pair.Value;//new HashSet<Object>(pair.Value);
}
i = 0;
Dictionary <Object, List <Sprite> > sprRefDictionary = Convert(allRecords);
foreach (var pair in sprRefDictionary)
{
SpriteTrackData sprData = new SpriteTrackData();
sprData.ShowMode = SpriteShowMode.Scene;
sprData.Id = AssetTreeManager.mIns.GetUniqueId();
sprData.DisplayName = pair.Key.name;
sprData.IconName = AssetTreeManager.mIns.GetIconName(AssetBundleResType.Cs);
sprData.SceneData.CsReferences = pair.Key as MonoBehaviour;
sprData.SceneData.InstanceId = pair.Key.GetInstanceID();
sprData.SceneData.MemSize = AssetBundleEditorHelper.ConvertSize(Profiler.GetRuntimeMemorySizeLong(pair.Key));
if (sprData.SceneData.CsReferences)
{
sprData.SceneData.Path = GetPath(sprData.SceneData.CsReferences.gameObject);
}
dataModel.Add(ref sprData);
HashSet <string> hashset = HashSetPool <string> .Get();
foreach (var refsprite in pair.Value)
{
SpriteTrackData refData = BuildData(refsprite, pair.Key, SpriteShowMode.Scene, sprCache);
refData.UsedRefCount = 1;
dataModel.Add(ref refData);
dataModel.AddChild(ref sprData, ref refData);
hashset.Add(refData.SceneData.SprData.PackingTag);
}
sprData.UsedRefCount = hashset.Count;
//refresh
dataModel.Add(ref sprData);
HashSetPool <string> .Release(hashset);
dataModel.AddChild(ref displayRoot, ref sprData);
yield return(DisplayProgressBar("Parse Scene", "Parsing Sprite", (float)i / sprRefDictionary.Count));
i++;
}
}
