void RenderBottom()
{
GUI.BeginGroup(EditorContexts.mIns.GuiContext.ToolbarRect);
//var style = "miniButton";
var md = AssetBundleEditorHelper.GetMainMode(EditorContexts.mIns.Mode);
var lw = EditorGUIUtility.labelWidth;
var lt = EditorGUI.indentLevel;
EditorGUIUtility.labelWidth = 80;
EditorGUI.indentLevel = 0;
var newmd = (AssetWindow.WindowMode)EditorGUI.EnumPopup(new Rect(0, 0, 180, EditorGuiContext.GuiHeight), new GUIContent("Select Mode"), md);
EditorGUIUtility.labelWidth = lw;
EditorGUI.indentLevel = lt;
newmd = AssetBundleEditorHelper.GetMainMode(newmd);
if (newmd != md)
{
EditorContexts.mIns.Mode = newmd;
}
GUI.EndGroup();
}
void OnSortingChanged(MultiColumnHeader header)
{
if (GetRows().Count <= 1 || header.sortedColumnIndex < 0 || !header.canSort)
{
return;
}
var md = EditorContexts.mIns.Mode;
var render = AssetTreeManager.mIns.GetGuiRender(md);
if (render != null)
{
foreach (var subrender in render)
{
if (subrender.TypeMode == _viewMode)
{
IGuiTree treeRender = subrender as IGuiTree;
if (treeRender != null)
{
treeRender.Sort(header, rootItem, GetRows());
}
}
}
}
AssetBundleEditorHelper.TreeListChildren(rootItem, GetRows());
Repaint();
}
string GetSprInfo(ref SimpleSpriteInfo sprData)
{
return(string.Format("PackingTag:{0} MipMap:{1} BundleName:{2} Path:{3}",
sprData.PackingTag,
AssetBundleEditorHelper.GetColorText("{0}", Color.yellow, sprData.Mipmap),
AssetBundleEditorHelper.GetColorText("{0}", Color.blue, sprData.BundleName),
AssetBundleEditorHelper.GetColorText("{0}", Color.gray, sprData.AssetPath)));
}
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);
}
void RenderBotToolbar()
{
GUI.BeginGroup(EditorContexts.mIns.GuiContext.SpriteBotBarRect);
var style = "miniButton";
var md = AssetBundleEditorHelper.GetMainMode(EditorContexts.mIns.Mode);
var lw = EditorGUIUtility.labelWidth;
var lt = EditorGUI.indentLevel;
EditorGUIUtility.labelWidth = 80;
EditorGUI.indentLevel = 0;
var newmd = (AssetWindow.WindowMode)EditorGUI.EnumPopup(new Rect(0, 0, 180, EditorGuiContext.GuiHeight), new GUIContent("Select Mode"), md);
EditorGUIUtility.labelWidth = lw;
EditorGUI.indentLevel = lt;
newmd = AssetBundleEditorHelper.GetMainMode(newmd);
if (newmd != md)
{
EditorContexts.mIns.Mode = newmd;
}
if (GUI.Button(new Rect(190, 0, 80, EditorGuiContext.GuiHeight), "Expand All", style))
{
_treeView.ExpandAll();
}
if (GUI.Button(new Rect(280, 0, 80, EditorGuiContext.GuiHeight), "Collapse All", style))
{
_treeView.CollapseAll();
}
if (GUI.Button(new Rect(380, 0, 80, EditorGuiContext.GuiHeight), "Refresh", style))
{
EditorContexts.mIns.ForceModeChange(AssetWindow.WindowMode.ToolsSprite);
}
if (EditorContexts.mIns.GuiContext.UsablePaths != null && EditorContexts.mIns.GuiContext.UsablePaths.Count > 0)
{
if (GUI.Button(new Rect(500, 0, 100, EditorGuiContext.GuiHeight), "Select Path"))
{
GenericMenu menu = EditorContexts.mIns.GuiContext.Menu;
if (menu != null)
{
EditorContexts.mIns.GuiContext.Menu.ShowAsContext();
}
}
}
GUI.EndGroup();
}
SimpleSpriteInfo GetSpriteData(Dictionary <Sprite, SimpleSpriteInfo> sprCache, Sprite spr)
{
SimpleSpriteInfo data = new SimpleSpriteInfo();
if (sprCache.TryGetValue(spr, out data))
{
return(data);
}
else
{
data.Sprite = spr;
data.MemSize = AssetBundleEditorHelper.ConvertSize(Profiler.GetRuntimeMemorySizeLong(spr));
data.TexMemSize = AssetBundleEditorHelper.ConvertSize(Profiler.GetRuntimeMemorySizeLong(spr.texture));
data.InstanceId = spr.GetInstanceID();
data.TexSize = spr.rect.size;
data.AssetPath = AssetDatabase.GetAssetPath(spr);
data.TexName = spr.texture.name;
data.TexPath = AssetDatabase.GetAssetPath(spr.texture);
data.Importer = (TextureImporter)TextureImporter.GetAtPath(data.TexPath);
if (data.Importer)
{
data.Mipmap = data.Importer.mipmapEnabled;
data.BundleName = data.Importer.assetBundleName;
if (string.IsNullOrEmpty(data.Importer.spritePackingTag))
{
data.PackingTag = SimpleSpriteInfo.EmptyTag;
}
else
{
data.PackingTag = data.Importer.spritePackingTag;
}
}
else if (data.TexPath == "Resources/unity_builtin_extra")
{
data.PackingTag = BuildInTag;
}
else if (data.TexPath.EndsWith("/Resources") || data.TexPath.Contains("/Resources/"))
{
data.PackingTag = ResourcesTag;
}
else
{
Debug.LogError("Missing " + data.TexPath);
data.PackingTag = "Missing";
}
sprCache.Add(spr, data);
}
return(data);
}
int SortSelfFileSizeFunc(int left, int right)
{
DependencyTreeData ld;
DependencyTreeData rd;
if (_model.GetItem(left, out ld) && _model.GetItem(right, out rd))
{
long leftsize = AssetBundleEditorHelper.GetSelfFileSize(ref ld, ld.IsAssetBundleViewData, _model);
long rightsize = AssetBundleEditorHelper.GetSelfFileSize(ref rd, rd.IsAssetBundleViewData, _model);
return(_sortval * (int)(leftsize - rightsize));
}
return(0);
}
void AddEnumInfo <T>(T current, T optval, ref bool first) where T : struct, IConvertible
{
bool has = AssetBundleEditorHelper.HasEnum(current, optval);
if (has)
{
if (!first)
{
_stringBuilder.Append("|");
}
_stringBuilder.Append(optval.ToString());
first = false;
}
}
void RenderBottom()
{
GUI.BeginGroup(EditorContexts.mIns.GuiContext.ToolbarRect);
var style = "miniButton";
var md = AssetBundleEditorHelper.GetMainMode(EditorContexts.mIns.Mode);
var lw = EditorGUIUtility.labelWidth;
var lt = EditorGUI.indentLevel;
EditorGUIUtility.labelWidth = 80;
EditorGUI.indentLevel = 0;
var newmd = (AssetWindow.WindowMode)EditorGUI.EnumPopup(new Rect(0, 0, 180, EditorGuiContext.GuiHeight), new GUIContent("Select Mode"), md);
EditorGUIUtility.labelWidth = lw;
EditorGUI.indentLevel = lt;
newmd = AssetBundleEditorHelper.GetMainMode(newmd);
if (newmd != md)
{
EditorContexts.mIns.Mode = newmd;
}
if (GUI.Button(new Rect(190, 0, 80, EditorGuiContext.GuiHeight), "Expand All", style))
{
_treeView.ExpandAll();
}
if (GUI.Button(new Rect(280, 0, 80, EditorGuiContext.GuiHeight), "Collapse All", style))
{
_treeView.CollapseAll();
}
if (GUI.Button(new Rect(370, 0, 80, EditorGuiContext.GuiHeight), "Reload", style))
{
EditorContexts.mIns.ForceModeChange(EditorContexts.mIns.Mode);
if (_treeView == null)
{
Init();
_treeView.Reload();
}
}
//if (GUI.Button(new Rect(460, 0, 80, EditorGuiContext.GuiHeight), "ReInit", style))
//{
// EditorContexts.mIns.ForceModeChange(EditorContexts.mIns.Mode,true);
//}
GUI.EndGroup();
}
int SortSelfFileSizeFunc(TreeViewItem left, TreeViewItem right)
{
AssetTreeItem <DependencyTreeData> leftItem = left as AssetTreeItem <DependencyTreeData>;
AssetTreeItem <DependencyTreeData> rightItem = right as AssetTreeItem <DependencyTreeData>;
if (leftItem != null && rightItem != null)
{
var ld = leftItem.GetData();
var rd = rightItem.GetData();
long leftsize = AssetBundleEditorHelper.GetSelfFileSize(ref ld, left.depth == 0, _model);
long rightsize = AssetBundleEditorHelper.GetSelfFileSize(ref rd, left.depth == 0, _model);
return(_sortval * (int)(leftsize - rightsize));
}
return(0);
}
public int Execute(ref EditorSystemContext context, EditorEvent assetEvent)
{
if (assetEvent == EditorEvent.Enable)
{
#if UNITY_EDITOR
string path = GetOutputPath();
if (!string.IsNullOrEmpty(path))
{
string dirname = AssetBundleEditorHelper.GetDirectoryName(path);
string allabpath = path + "/" + dirname;
if (File.Exists(allabpath) && AssetBundleLoadManager.mIns != null)
{
int retcode = 0;
try
{
var allmanifest = AssetBundleLoadManager.mIns.GetManifest(allabpath);
if (allmanifest != null)
{
if (context.Manifests == null)
{
context.Manifests = new Dictionary <string, AssetBundleBuildInfo>();
}
else
{
context.Manifests.Clear();
}
var ablist = allmanifest.GetAllAssetBundles();
foreach (var assetbundlename in ablist)
{
AssignMainfest(ref context, allmanifest, path, assetbundlename);
}
}
}
catch (Exception e)
{
Debug.LogError(e);
retcode = -1;
}
return(retcode);
}
}
#endif
}
return(0);
}
SimpleGoData GetGoData(Object target)
{
GameObject gameObject = null;
if (target is GameObject)
{
gameObject = target as GameObject;
}
else if (target is MonoBehaviour)
{
gameObject = (target as MonoBehaviour).gameObject;
}
SimpleGoData data = new SimpleGoData();
data.Go = gameObject;
data.InstanceId = target.GetInstanceID();
data.AssetPath = AssetDatabase.GetAssetPath(gameObject);
data.Path = GetPath(gameObject);
data.PrefabType = PrefabUtility.GetPrefabType(gameObject);
data.MemSize = AssetBundleEditorHelper.ConvertSize(Profiler.GetRuntimeMemorySizeLong(target));
return(data);
}
void RenderOption()
{
var style = GUI.skin.FindStyle("flow node 2");
GUI.BeginGroup(EditorContexts.mIns.GuiContext.OptionRect, style);
GUI.Label(new Rect(0, 0, 50, EditorGuiContext.GuiHeight), "Option:");
var lw = EditorGUIUtility.labelWidth;
var lt = EditorGUI.indentLevel;
EditorGUIUtility.labelWidth = 140;
EditorGUI.indentLevel = 0;
BuildAssetBundleOptions optval = (BuildAssetBundleOptions)((int)GetBuildAbOptions() << 1);
BuildAssetBundleOptions optnewval = (BuildAssetBundleOptions)EditorGUI.EnumMaskField(new Rect(40, EditorGuiContext.GuiHeight, 350, EditorGuiContext.GuiHeight), new GUIContent("AssetBundle Options"), optval);
if (optnewval != optval)
{
EditorPrefs.SetInt(BuildOptKey, (int)optnewval);
}
BuildTarget target = EditorUserBuildSettings.activeBuildTarget;
var newtarget = (BuildTarget)EditorGUI.EnumPopup(new Rect(40, 2 * EditorGuiContext.GuiHeight, 350, EditorGuiContext.GuiHeight),
new GUIContent("BuildTarget"), target);
if (newtarget != target)
{
if (EditorUtility.DisplayDialog("info", "Change to " + newtarget, "yes", "no"))
{
EditorUserBuildSettings.SwitchActiveBuildTarget(ConvertBuildTarget(newtarget), newtarget);
}
}
EditorGUIUtility.labelWidth = lw;
EditorGUI.indentLevel = lt;
bool oldgen = GetAutoDep();
bool newval = GUI.Toggle(new Rect(40, 3 * EditorGuiContext.GuiHeight, 160, EditorGuiContext.GuiHeight), oldgen, "Auto Generate Dep");
if (newval != oldgen)
{
EditorPrefs.SetBool(AutoGenDepKey, newval);
}
if (GUI.Button(new Rect(40, 4 * EditorGuiContext.GuiHeight + 5, 80, EditorGuiContext.GuiHeight), "Build"))
{
StartBuild();
}
if (GUI.Button(new Rect(125, 4 * EditorGuiContext.GuiHeight + 5, 120, EditorGuiContext.GuiHeight), "Build DepFile"))
{
GenerateDependencyInfo();
}
if (GUI.Button(new Rect(250, 4 * EditorGuiContext.GuiHeight + 5, 190, EditorGuiContext.GuiHeight), "Copy to StreamAssets"))
{
string streampath = AssetBundleHelper.StreamingAssetsPath;
if (!Directory.Exists(streampath))
{
Directory.CreateDirectory(streampath);
}
AssetBundleEditorHelper.DirectoryCopy(GetOutputPath(), streampath);
AssetDatabase.Refresh();
}
if (GUI.Button(new Rect(445, 4 * EditorGuiContext.GuiHeight + 5, 140, EditorGuiContext.GuiHeight), "Clear StreamAssets"))
{
string streampath = AssetBundleHelper.StreamingAssetsPath;
if (Directory.Exists(streampath))
{
FileUtil.DeleteFileOrDirectory(AssetBundleEditorHelper.GetUnityAssetPath(streampath));
AssetDatabase.Refresh();
}
}
if (GUI.Button(new Rect(590, 4 * EditorGuiContext.GuiHeight + 5, 120, EditorGuiContext.GuiHeight), "Clear BuildPath"))
{
string buildpath = GetOutputPath();
if (Directory.Exists(buildpath))
{
FileUtil.DeleteFileOrDirectory(AssetBundleEditorHelper.GetUnityAssetPath(buildpath));
AssetDatabase.Refresh();
}
}
GUI.EndGroup();
}
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);
}
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++;
}
}
void RenderInfo()
{
var style = GUI.skin.FindStyle("flow node 2");
style.alignment = TextAnchor.UpperLeft;
//GUI.BeginGroup(EditorContexts.mIns.BuildInfoRect);
using (var scope = new EditorGUILayout.VerticalScope())
{
GUILayout.BeginArea(EditorContexts.mIns.GuiContext.BuildInfoRect);
_scrollpos = GUILayout.BeginScrollView(_scrollpos);
var col = GUI.skin.label.normal.textColor;
GUI.skin.label.normal.textColor = Color.white;
GUI.skin.label.richText = true;
var allassetnames = AssetDatabase.GetAllAssetBundleNames();
GUILayout.Label(string.Format("Will Build {0} AsseetBundles\n", AssetBundleEditorHelper.GetColorText("{0}", Color.red, allassetnames.Length)));
var currenttarget = EditorUserBuildSettings.activeBuildTarget;
GUILayout.Label(string.Format("Build Target:{0}\n", AssetBundleEditorHelper.GetColorText("{0}", Color.yellow, currenttarget)));
GUILayout.Label(string.Format("BuildOption:{0}\n", AssetBundleEditorHelper.GetColorText("{0}", Color.yellow, GetOptionInfo())));
GUILayout.Label(AssetBundleEditorHelper.GetColorText("{0}", Color.cyan, "AssetBundleOption Helper:\n"));
GUILayout.Label("UncompressedAssetBundle:" + AssetBundleEditorHelper.GetColorText("{0}\n", Color.yellow,
"This bundle option builds the bundles in such a way that the data is completely uncompressed. The downside to being uncompressed is the larger file download size. However, the load times once downloaded will be much faster."));
GUILayout.Label("DisableWriteTypeTree:" + AssetBundleEditorHelper.GetColorText("{0}\n", Color.yellow,
"Do not include type information within the AssetBundle."));
GUILayout.Label("DeterministicAssetBundle:" + AssetBundleEditorHelper.GetColorText("{0}\n", Color.yellow,
"Builds an asset bundle using a hash for the id of the object stored in the asset bundle.When building the asset bundle with this method, the objects in it are assigned a 32 bit hash code that is calculated using the name of the asset bundle file, \n\tthe GUID of the asset and the local id of the object in the asset.For that reason make sure to use the same file name when rebuilding. \n\tAlso note that having a lot of objects might cause hash collisions preventing Unity from building the asset bundle."));
GUILayout.Label("ForceRebuildAssetBundle:" + AssetBundleEditorHelper.GetColorText("{0}\n", Color.yellow,
"Force rebuild the assetBundles"));
GUILayout.Label("IgnoreTypeTreeChanges:" + AssetBundleEditorHelper.GetColorText("{0}\n", Color.yellow,
"Ignore the type tree changes when doing the incremental build check."));
GUILayout.Label("AppendHashToAssetBundleName:" + AssetBundleEditorHelper.GetColorText("{0}\n", Color.yellow,
"Append the hash to the assetBundle name."));
GUILayout.Label("ChunkBasedCompression:" + AssetBundleEditorHelper.GetColorText("{0}\n", Color.yellow,
" This bundle option uses a compression method known as LZ4, which results in larger compressed file sizes than LZMA but does not require that entire bundle is decompressed,\n\tunlike LZMA, before it can be used. LZ4 uses a chunk based algorithm which allows the AssetBundle be loaded in pieces or “chunks.”\n\tDecompressing a single chunk allows the contained assets to be used even if the other chunks of the AssetBundle are not decompressed."));
GUILayout.Label("StrictMode:" + AssetBundleEditorHelper.GetColorText("{0}\n", Color.yellow,
"Do not allow the build to succeed if any errors are reporting during it."));
GUILayout.Label("DryRunBuild:" + AssetBundleEditorHelper.GetColorText("{0}\n", Color.yellow,
"Do a dry run build.."));
GUI.skin.label.richText = false;
GUI.skin.label.normal.textColor = col;
GUILayout.EndScrollView();
GUILayout.EndArea();
}
}
public bool CellGui(TreeViewItem item, ref AssetRowGuiArgs args)
{
var assetitem = item as AssetTreeItem <DependencyTreeData>;
if (assetitem != null)
{
var data = assetitem.GetData();
var runtimeInfo = data.EditorInfo.RuntimeInfo;
bool isroot = item.depth == 0;
var topmenutype = (TopMenu)args.Column;
if (topmenutype == TopMenu.Name)
{
return(false);
}
else if (topmenutype == TopMenu.ResType)
{
GUI.Label(args.CellRect, GetResTypeContent(runtimeInfo.AssetResType));
}
else if (topmenutype == TopMenu.Size)//size
{
long size = AssetBundleEditorHelper.GetAssetSize(ref data, isroot, _model);
GUI.Label(args.CellRect, AssetBundleEditorHelper.ConvertSize(size));
}
else if (topmenutype == TopMenu.FileSize)//file size
{
long size = AssetBundleEditorHelper.GetFileSize(ref data, isroot, _model);
GUI.Label(args.CellRect, AssetBundleEditorHelper.ConvertSize(size));
}
else if (topmenutype == TopMenu.SelfSize)//size
{
long size = AssetBundleEditorHelper.GetSelfAssetSize(ref data, isroot, _model);
GUI.Label(args.CellRect, AssetBundleEditorHelper.ConvertSize(size));
}
else if (topmenutype == TopMenu.SelfFileSize)//file size
{
long size = AssetBundleEditorHelper.GetSelfFileSize(ref data, isroot, _model);
GUI.Label(args.CellRect, AssetBundleEditorHelper.ConvertSize(size));
}
else if (topmenutype == TopMenu.BeDependOn)
{
if (isroot)
{
var list = _model.GetDependParents(runtimeInfo.UnityPath);
GUI.skin.label.richText = true;
var info = AssetBundleEditorHelper.GetColorText("be depond on count :{0}", Color.grey, list.Count.ToString());
if (!string.IsNullOrEmpty(data.EditorInfo.RuntimeInfo.AssetBundleName))
{
info += AssetBundleEditorHelper.GetColorText(" AssetBundle Name :{0},It should be Load {0} first", Color.yellow, data.EditorInfo.RuntimeInfo.AssetBundleName);
}
else
{
info += AssetBundleEditorHelper.GetColorText(" it's an noassetbundlename resource,it will pack into this assetbundle alonely", Color.white);
}
GUI.Label(args.CellRect, new GUIContent(info));
GUI.skin.label.richText = false;
}
}
return(true);
}
else
{
return(false);
}
}
//List<AssetTreeItem<AssetTreeData>g> GetSelectItems()
//{
// var selects = _treeView.GetSelection();
// List<AssetTreeItem<AssetTreeData>> list = ListPool<AssetTreeItem<AssetTreeData>>.Get();
// foreach (var id in selects)
// {
// for (int i = 0; i < _treeView.GetRows().Count; i++)
// {
// var item = _treeView.GetRows()[i];
// if (item.id == id)
// {
// list.Add(item as AssetTreeItem<AssetTreeData>);
// break;
// }
// }
// }
// return list;
//}
public bool CellGui(TreeViewItem item, ref AssetRowGuiArgs args)
{
var assetitem = item as AssetTreeItem <AssetTreeData>;
if (assetitem != null)
{
var data = assetitem.GetData();
var runtimeInfo = data.EditorInfo.RuntimeInfo;
bool isroot = item.depth == 0;
var topmenutype = (TopMenu)args.Column;
if (topmenutype == TopMenu.AssetBundle)
{
//GUI.Label(args.CellRect, new GUIContent(item.displayName, item.icon));
return(false);
}
else if (topmenutype == TopMenu.InAssetBundle)
{
if (!isroot)
{
bool isIn = !string.IsNullOrEmpty(runtimeInfo.AssetBundleName) && item.depth <= 1;
bool value = GUI.Toggle(args.CellRect, isIn, "");
if (isIn != value)
{
if (value)
{
if (item.parent != null && item.parent.parent != null)
{
AssetImporter importer = AssetImporter.GetAtPath(runtimeInfo.UnityPath);
if (importer != null)
{
importer.assetBundleName = item.parent.parent.displayName;
importer.SaveAndReimport();
}
EditorContexts.mIns.ForceModeChange(EditorContexts.mIns.Mode);
}
else
{
Debug.LogErrorFormat("{0} parent is Null", runtimeInfo.UnityPath);
}
}
else
{
AssetImporter importer = AssetImporter.GetAtPath(runtimeInfo.UnityPath);
if (importer != null)
{
importer.assetBundleName = "";
importer.SaveAndReimport();
}
EditorContexts.mIns.ForceModeChange(EditorContexts.mIns.Mode);
}
}
}
}
else if (topmenutype == TopMenu.ResType) //
{
if (!isroot)
{
var restype = data.EditorInfo.RuntimeInfo.AssetResType;
EditorGUI.EnumPopup(args.CellRect, restype);
}
else
{
//EditorGUIUtility.FindTexture(AssetTreeManager.mIns.GetIconName("Folder"))
GUI.Label(args.CellRect, new GUIContent("ab", "Asset Bundle"));
}
}
else if (topmenutype == TopMenu.Size)//size
{
long size = AssetBundleEditorHelper.GetAssetSize(ref data, isroot, _model);
GUI.Label(args.CellRect, AssetBundleEditorHelper.ConvertSize(size));
}
else if (topmenutype == TopMenu.FileSize)//file size
{
long size = AssetBundleEditorHelper.GetFileSize(ref data, isroot, _model);
GUI.Label(args.CellRect, AssetBundleEditorHelper.ConvertSize(size));
}
else if (topmenutype == TopMenu.SelfSize)//size
{
long size = AssetBundleEditorHelper.GetSelfAssetSize(ref data, isroot, _model);
GUI.Label(args.CellRect, AssetBundleEditorHelper.ConvertSize(size));
}
else if (topmenutype == TopMenu.SelfFileSize)//file size
{
long size = AssetBundleEditorHelper.GetSelfFileSize(ref data, isroot, _model);
GUI.Label(args.CellRect, AssetBundleEditorHelper.ConvertSize(size));
}
else if (topmenutype == TopMenu.Dependency) //dependencies
{
if (!isroot)
{
if (runtimeInfo.DependenciesCnt == 0)
{
GUI.enabled = false;
}
if (GUI.Button(args.CellRect, new GUIContent(runtimeInfo.DependenciesCnt.ToString())))
{
if (EditorContexts.mIns.Mode != AssetWindow.WindowMode.AssetDependency ||
!_selectfile.Equals(runtimeInfo.UnityPath) || EditorContexts.mIns.GuiContext.SelectDepth != 0)
{
_selectfile = runtimeInfo.UnityPath;
AssetTreeData selectData;
if (_model.GetItem(runtimeInfo.UnityPath, out selectData))
{
EditorContexts.mIns.SelectForDependencyData = selectData;
}
EditorContexts.mIns.GuiContext.SelectDepth = 0;
if (EditorContexts.mIns.Mode != AssetWindow.WindowMode.AssetDependency)
{
EditorContexts.mIns.Mode = AssetWindow.WindowMode.AssetDependency;
}
else
{
EditorContexts.mIns.ForceModeChange(AssetWindow.WindowMode.AssetDependency);
}
}
else
{
EditorContexts.mIns.Mode = AssetWindow.WindowMode.Asset;
}
//_treeView.FrameItem(item.id);
var selectedIDs = new List <int>();
selectedIDs.Add(item.id);
_treeView.SetSelection(selectedIDs, TreeViewSelectionOptions.RevealAndFrame);
}
if (runtimeInfo.DependenciesCnt == 0)
{
GUI.enabled = true;
}
}
}
else if (topmenutype == TopMenu.BeDepend)
{
if (!isroot)
{
var list = _model.GetDependParents(runtimeInfo.UnityPath);
if (list.Count == 0)
{
GUI.enabled = false;
}
if (GUI.Button(args.CellRect, list.Count.ToString()))
{
if (EditorContexts.mIns.Mode != AssetWindow.WindowMode.AssetDependency ||
!_selectfile.Equals(runtimeInfo.UnityPath) || EditorContexts.mIns.GuiContext.SelectDepth != 1)
{
_selectfile = runtimeInfo.UnityPath;
AssetTreeData selectData;
if (_model.GetItem(runtimeInfo.UnityPath, out selectData))
{
EditorContexts.mIns.SelectForDependencyData = selectData;
}
EditorContexts.mIns.GuiContext.SelectDepth = 1;
if (EditorContexts.mIns.Mode != AssetWindow.WindowMode.AssetDependency)
{
EditorContexts.mIns.Mode = AssetWindow.WindowMode.AssetDependency;
}
else
{
EditorContexts.mIns.ForceModeChange(AssetWindow.WindowMode.AssetDependency);
}
}
else
{
EditorContexts.mIns.Mode = AssetWindow.WindowMode.Asset;
}
//_treeView.FrameItem(item.id);
var selectedIDs = new List <int>();
selectedIDs.Add(item.id);
_treeView.SetSelection(selectedIDs, TreeViewSelectionOptions.RevealAndFrame);
}
GUI.enabled = true;
ListPool <AssetTreeData> .Release(list);
}
}
else if (topmenutype == TopMenu.Info) //info
{
GUI.skin.label.richText = true;
if (!isroot)
{
string info = AssetBundleEditorHelper.GetColorText(" Path :{0}", Color.yellow, runtimeInfo.UnityPath);
GUI.Label(args.CellRect, info);
}
else
{
string info = string.Format("Path:{0}", runtimeInfo.UnityPath);
info += AssetBundleEditorHelper.GetColorText(" Hash :{0}", Color.grey, runtimeInfo.HashCode);
info += AssetBundleEditorHelper.GetColorText(" Crc :{0}", Color.white, runtimeInfo.Crc);
if (HasNoAssetBundleName(ref data))
{
GUI.Label(args.CellRect, new GUIContent(info, AssetTreeManager.mIns.GetEditorTexture("warning")));
}
else
{
GUI.Label(args.CellRect, info);
}
}
GUI.skin.label.richText = false;
}
return(true);
}
return(false);
}
