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);
}
}
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++;
}
}
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++;
}
}
}
}
AssetTreeData CreateSubAssetBundle(AssetTreeModel <AssetTreeData> dataModel, int parentid, string assetpath, string assetbundlename)
{
AssetTreeData data = new AssetTreeData();
data.Id = AssetTreeManager.mIns.GetUniqueId();
CreateAssetBundleInfo(ref data, assetpath, assetbundlename);
dataModel.Add(ref data);
dataModel.AddChild(parentid, data.Id);
return(data);
}
AssetTreeData CreateBaseAssetBundle(string[] assetpaths, string assetbundlename, AssetTreeModel <AssetTreeData> dataModel)
{
AssetTreeData folderData = new AssetTreeData();
folderData.Id = AssetTreeManager.mIns.GetUniqueId();
folderData.DisplayName = assetbundlename;
folderData.IconName = AssetTreeManager.mIns.GetIconName("Folder");
folderData.FilePath = Path.GetDirectoryName(assetpaths[0]);
//set Folder
var info = folderData.EditorInfo;
var runtimeinfo = info.RuntimeInfo;
runtimeinfo.UnityPath = folderData.FilePath;
runtimeinfo.DependNames = assetpaths;
runtimeinfo.DepAssetBundleNames = new string[assetpaths.Length];
for (int i = 0; i < assetpaths.Length; i++)
{
var import = AssetImporter.GetAtPath(assetpaths[i]);
if (import != null)
{
runtimeinfo.DepAssetBundleNames[i] = import.assetBundleName;
}
}
//hash
if (EditorContexts.mIns.SystemContext.Manifests != null)
{
AssetBundleBuildInfo buildinfo;
if (EditorContexts.mIns.SystemContext.Manifests.TryGetValue(assetbundlename, out buildinfo))
{
runtimeinfo.HashCode = buildinfo.AssetBundleHash;
runtimeinfo.Crc = buildinfo.Crc;
}
}
info.RuntimeInfo = runtimeinfo;
folderData.EditorInfo = info;
dataModel.AddChild(dataModel.Root.Id, folderData.Id);
dataModel.Add(ref folderData);
return(folderData);
}
IEnumerator CreateDepParent(AssetTreeModel <DependencyTreeData> datamodel, AssetTreeModel <AssetTreeData> treemodel, string filepath, int parentId)
{
var dependonlist = treemodel.GetDependParents(filepath);
foreach (var element in dependonlist)
{
DependencyTreeData subdata = new DependencyTreeData();
Convert(ref subdata, element);
datamodel.Add(ref subdata);
datamodel.AddChild(parentId, subdata.Id);
_progress++;
if (_progress % AssetWindowConfig.ParseStep == 0)
{
#if !UNITY_EDITOR_OSX
yield return(DisplayProgressBar("Dependency-Parse", "Parse Dependency for :" + element.FilePath, 0));
#endif
}
}
}
IEnumerator ParseSelect(AssetTreeModel <DependencyTreeData> datamodel, AssetTreeModel <AssetTreeData> treemodel, AssetTreeData data)
{
#if !UNITY_EDITOR_OSX
yield return(DisplayProgressBar("Dependency-Parse", "Parse Dependency for :" + data.FilePath, 0f));
#endif
DependencyTreeData root = new DependencyTreeData();
root.Id = AssetTreeManager.mIns.GetUniqueId();
root.DisplayName = "root";
//empty;
datamodel.Root = root;
datamodel.Add(ref root);
_progress = 0;
if (EditorContexts.mIns.GuiContext.SelectDepth == 0)
{
foreach (var dependency in data.EditorInfo.Dependencies)
{
DependencyTreeData depdata = new DependencyTreeData();
depdata.Id = AssetTreeManager.mIns.GetUniqueId();
depdata.IsAssetBundleViewData = true;
CreateDependencyInfo(ref depdata, dependency);
datamodel.Add(ref depdata);
yield return(CreateDepParent(datamodel, treemodel, depdata.FilePath, depdata.Id));
datamodel.AddChild(ref root, ref depdata);
}
}
else
{
yield return(CreateDepParent(datamodel, treemodel, data.FilePath, root.Id));
}
yield return(null);
Inited = true;
EditorUtility.ClearProgressBar();
}
IEnumerator ParseAssetBundle(AssetTreeModel <AssetTreeData> dataModel, Dictionary <string, string[]> assetbundleDictionary, int total)
{
//create root
AssetTreeData rootData = new AssetTreeData();
rootData.Id = AssetTreeManager.mIns.GetUniqueId();
dataModel.Root = rootData;
dataModel.Add(ref rootData);
//Editor Ui
int progress = 0;
float totalprogress = total + 2;
yield return(DisplayProgressBar("Asset-Parse AssetBundle", "Start Parseing", 0f));
foreach (var assetbundleinfo in assetbundleDictionary)
{
var assetbundlename = assetbundleinfo.Key;
var assetpaths = assetbundleinfo.Value;
if (assetpaths.Length > 0)
{
AssetTreeData folderData = CreateBaseAssetBundle(assetpaths, assetbundlename, dataModel);
folderData.IsAssetBundleViewData = true;
foreach (var assetpath in assetpaths)
{
CreateSubAssetBundle(dataModel, folderData.Id, assetpath, assetbundlename);
//Editor Ui
progress++;
if (progress % AssetWindowConfig.ParseStep == 0)
{
yield return(DisplayProgressBar("Asset-Parse AssetBundle", "Parseing " + assetpath, progress / totalprogress));
}
}
}
}
yield return(DisplayProgressBar("Asset-Parse AssetBundle", "Set Dependency", (progress + 1) / totalprogress));
List <AssetTreeData> nonamelist = new List <AssetTreeData>();
Stack <AssetTreeData> itemStack = StackPool <AssetTreeData> .Get();
var allTreeDatas = dataModel.GetAllItems();
//set dependency references
for (int i = 0; i < allTreeDatas.Count; i++)
{
var info = allTreeDatas[i];
itemStack.Push(info);
//SetAssetDependRef(ref info,dataModel,nonamelist);
}
ListPool <AssetTreeData> .Release(allTreeDatas);
yield return(SetAssetDependRef(itemStack, dataModel, nonamelist));
StackPool <AssetTreeData> .Release(itemStack);
yield return(DisplayProgressBar("Asset-Parse AssetBundle", "Assigning NoAssetName", 1f));
for (int i = 0; i < nonamelist.Count; i++)
{
var nonameitem = nonamelist[i];
var deplist = dataModel.GetDependParents(nonameitem.FilePath);
for (int j = 0; j < deplist.Count; j++)
{
var dep = deplist[j];
if (j == 0)
{
dataModel.AddChild(dep.Id, nonameitem.Id);
}
else
{
nonameitem.Id = AssetTreeManager.mIns.GetUniqueId();
dataModel.Add(ref nonameitem);
//dataModel.AddViewData(ref nonameitem);
dataModel.AddChild(dep.Id, nonameitem.Id);
}
}
}
yield return(null);
EditorUtility.ClearProgressBar();
}
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++;
}
}
IEnumerator AddProfilerData(AssetTreeModel <RuntimeProfilerData> datamodel, FrameProfilerData data, RuntimeProfilerData taskroot, RuntimeProfilerData bundleroot)
{
int step = 5;
if (data.Tasks != null)
{
for (int i = 0; i < data.Tasks.Count; i++)
{
var task = data.Tasks[i];
RuntimeProfilerData folderdata = new RuntimeProfilerData();
folderdata.Id = AssetTreeManager.mIns.GetUniqueId();
folderdata.DisplayName = Path.GetFileNameWithoutExtension(task.AssetPath);
folderdata.IconName = AssetTreeManager.mIns.GetIconName("Folder");
folderdata.Task = task;
datamodel.Add(ref folderdata);
datamodel.AddChild(ref taskroot, ref folderdata);
if (i % step == 0)
{
yield return(null);
}
}
}
if (data.Histories != null)
{
for (int i = 0; i < data.Histories.Count; i++)
{
var history = data.Histories[i];
RuntimeProfilerData folderdata = new RuntimeProfilerData();
folderdata.Id = AssetTreeManager.mIns.GetUniqueId();
folderdata.DisplayName = history.AssetBundlename;
folderdata.IconName = AssetTreeManager.mIns.GetIconName("Folder");
folderdata.History = history;
datamodel.Add(ref folderdata);
datamodel.AddChild(ref bundleroot, ref folderdata);
if (history.AssetsList != null)
{
foreach (var sub in history.AssetsList)
{
RuntimeProfilerData subdata = new RuntimeProfilerData();
subdata.Id = AssetTreeManager.mIns.GetUniqueId();
subdata.DisplayName = Path.GetFileNameWithoutExtension(sub.Path);
subdata.IconName = AssetTreeManager.mIns.GetIconName("GameObject");
subdata.AssetInfo = sub;
datamodel.Add(ref subdata);
datamodel.AddChild(ref folderdata, ref subdata);
}
}
if (i % step == 0)
{
yield return(null);
}
}
}
yield return(null);
}
