681 lines
25 KiB
C#
681 lines
25 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using UnityEditor;
|
|
|
|
using UnityEditorInternal;
|
|
using UnityEngine;
|
|
using UnityEngine.SceneManagement;
|
|
using Object = UnityEngine.Object;
|
|
|
|
namespace Utilities.AssetsCache
|
|
{
|
|
public class AssetsCache : EditorWindow
|
|
{
|
|
private const string StrSaveName = "AssetsCacheSave";
|
|
private const string StrShowTab = "Show Tabs";
|
|
private const string StrHideTab = "Hide Tabs";
|
|
private const string StrDone = "Done";
|
|
private const string StrEdit = "Edit";
|
|
private const string StrReset = "Reset";
|
|
private const string StrDrag = "Drag and drop assets here";
|
|
|
|
public List<CacheTabInfo> tabs = new List<CacheTabInfo>() { new CacheTabInfo { id = 0, tabName = "Common" } };
|
|
public List<CacheObjectInfo> objects = new List<CacheObjectInfo>();
|
|
public List<CacheObjectInfo> filterList = new List<CacheObjectInfo>();
|
|
|
|
public string searchText = string.Empty;
|
|
private string _oldSearchText;
|
|
private Vector2 _objectsScrollPosition;
|
|
private Vector2 _tabsScrollPosition;
|
|
private EditorCacheStyle _s;
|
|
private int _oldTabIndex = -1;
|
|
private int _tabIndex;
|
|
private bool _isEditMode;
|
|
private bool _isShowTabs;
|
|
private ReorderableList _objectsReorderableList;
|
|
private ReorderableList _tabsReorderableList;
|
|
|
|
private float _currentTabViewWidth;
|
|
private bool _isResize;
|
|
private Rect _cursorChangeRect;
|
|
|
|
private void OnEnable()
|
|
{
|
|
_oldSearchText = "old";
|
|
InitReOrderTabList();
|
|
|
|
_currentTabViewWidth = 110;
|
|
_cursorChangeRect = new Rect(_currentTabViewWidth, 0, 5, position.size.y);
|
|
}
|
|
|
|
[MenuItem("Tools/Assets Cache")]
|
|
public static void Init()
|
|
{
|
|
var w = GetWindow<AssetsCache>();
|
|
w.titleContent.text = "Assets Cache";
|
|
w.Read();
|
|
w.Show();
|
|
}
|
|
|
|
private void InitReOrderTabList()
|
|
{
|
|
_tabsReorderableList = new ReorderableList(tabs, typeof(CacheTabInfo), true, false, true, true);
|
|
_tabsReorderableList.drawElementCallback += DrawTabElementCallback;
|
|
_tabsReorderableList.onChangedCallback += _ => { Save(); };
|
|
_tabsReorderableList.onAddCallback += _ => { AddNewTab(); };
|
|
}
|
|
|
|
private void FilterWhenTabChanged()
|
|
{
|
|
if (_oldTabIndex != _tabIndex)
|
|
{
|
|
if (tabs.Count > 0)
|
|
{
|
|
_oldTabIndex = _tabIndex;
|
|
if (tabs[_tabIndex].list == null) tabs[_tabIndex].list = new List<CacheObjectInfo>();
|
|
objects = tabs[_tabIndex].list;
|
|
Filter();
|
|
}
|
|
else
|
|
tabs = new List<CacheTabInfo> { new CacheTabInfo() { id = 0, tabName = "Common" } };
|
|
}
|
|
}
|
|
|
|
private void OnGUI()
|
|
{
|
|
if (_s == null) _s = new EditorCacheStyle();
|
|
FilterWhenTabChanged();
|
|
DisplayTopBar();
|
|
GUILayout.BeginHorizontal();
|
|
if (_isShowTabs)
|
|
DisplayTabs();
|
|
DisplayObjectGroup();
|
|
GUILayout.EndHorizontal();
|
|
Repaint();
|
|
}
|
|
|
|
private void DisplayObjects()
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
_objectsScrollPosition = GUILayout.BeginScrollView(_objectsScrollPosition);
|
|
if (_isEditMode) DisplayReorderList();
|
|
else DisplayListObjects();
|
|
GUILayout.EndScrollView();
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void DisplayObjectGroup()
|
|
{
|
|
if (objects == null) return;
|
|
DisplayObjects();
|
|
DisplayDetail();
|
|
UpdateDragAndDrop();
|
|
}
|
|
|
|
private void DisplayTopBar()
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
if (GUILayout.Button(!_isShowTabs ? StrShowTab : StrHideTab, _s.buttonStyle, _s.expandWidthFalse))
|
|
{
|
|
_isShowTabs = !_isShowTabs;
|
|
}
|
|
|
|
searchText = EditorGUILayout.TextField(searchText, _s.toolbarSeachTextField);
|
|
GUILayout.Label($"{filterList.Count.ToString()}/{objects.Count.ToString()}", GUILayout.ExpandWidth(false));
|
|
if (GUILayout.Button(StrReset, EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
|
|
{
|
|
objects.Clear();
|
|
filterList.Clear();
|
|
Focus();
|
|
Save();
|
|
}
|
|
|
|
if (_oldSearchText != searchText)
|
|
{
|
|
_oldSearchText = searchText;
|
|
Filter();
|
|
}
|
|
|
|
if (!_isEditMode)
|
|
{
|
|
if (GUILayout.Button(StrEdit, _s.buttonStyle, _s.expandWidthFalse))
|
|
{
|
|
_isEditMode = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GUILayout.Button(StrDone, _s.buttonStyle, _s.expandWidthFalse))
|
|
{
|
|
_isEditMode = false;
|
|
}
|
|
}
|
|
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void DisplayDetail()
|
|
{
|
|
}
|
|
|
|
private void DisplayReorderList()
|
|
{
|
|
GUILayout.BeginVertical();
|
|
_objectsReorderableList.DoLayoutList();
|
|
GUILayout.EndVertical();
|
|
}
|
|
|
|
private void DisplayListObjects()
|
|
{
|
|
GUILayout.BeginVertical();
|
|
if (filterList.Count == 0)
|
|
{
|
|
EditorGUI.BeginDisabledGroup(true);
|
|
GUILayout.Label(StrDrag, _s.textEmpty);
|
|
EditorGUI.EndDisabledGroup();
|
|
}
|
|
|
|
foreach (var o in filterList)
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
if (o.previewTexture == null)
|
|
{
|
|
o.previewTexture = AssetPreview.GetAssetPreview(o.obj);
|
|
if (o.previewTexture == null)
|
|
{
|
|
o.previewTexture = AssetPreview.GetMiniThumbnail(o.obj);
|
|
}
|
|
}
|
|
|
|
GUILayout.Label(o.previewTexture, _s.previewTexture);
|
|
var lastPreviewRect = GUILayoutUtility.GetLastRect();
|
|
if (lastPreviewRect.Contains(Event.current.mousePosition))
|
|
{
|
|
if (Event.current.type == EventType.MouseDown)
|
|
{
|
|
GUIUtility.hotControl = 0;
|
|
DragAndDrop.PrepareStartDrag();
|
|
DragAndDrop.objectReferences = new[] { o.obj };
|
|
DragAndDrop.SetGenericData("DRAG_ID", o.obj);
|
|
DragAndDrop.StartDrag("A");
|
|
}
|
|
}
|
|
|
|
if (GUILayout.Button(new GUIContent(o.GetDisplayName()), _s.buttonStyle, null))
|
|
{
|
|
tabs[_tabIndex].selected = o;
|
|
tabs[_tabIndex].editor = Editor.CreateEditor(o.obj);
|
|
if (o.location == CacheObjectLocation.Scene || o.location == CacheObjectLocation.Prefab)
|
|
{
|
|
o.Ping();
|
|
}
|
|
else if (o.obj is DefaultAsset)
|
|
{
|
|
EditorCacheHelper.ShowFolderContents(o.obj.GetInstanceID());
|
|
}
|
|
else
|
|
{
|
|
AssetDatabase.OpenAsset(o.obj);
|
|
}
|
|
}
|
|
|
|
if (GUILayout.Button("P", _s.expandWidthFalse))
|
|
{
|
|
o.Ping();
|
|
}
|
|
|
|
if (GUILayout.Button("-", _s.expandWidthFalse))
|
|
{
|
|
objects.Remove(o);
|
|
filterList.Remove(o);
|
|
Save();
|
|
Focus();
|
|
break;
|
|
}
|
|
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
GUILayout.EndVertical();
|
|
}
|
|
|
|
private void ResizeScrollView()
|
|
{
|
|
//GUI.DrawTexture(_cursorChangeRect, null);
|
|
EditorGUIUtility.AddCursorRect(_cursorChangeRect, MouseCursor.ResizeHorizontal);
|
|
|
|
if (Event.current.type == EventType.MouseDown && _cursorChangeRect.Contains(Event.current.mousePosition))
|
|
{
|
|
_isResize = true;
|
|
}
|
|
if (_isResize)
|
|
{
|
|
_currentTabViewWidth = Event.current.mousePosition.x;
|
|
_currentTabViewWidth = Mathf.Clamp(_currentTabViewWidth, 100, 200);
|
|
_cursorChangeRect.Set(_currentTabViewWidth, _cursorChangeRect.y, _cursorChangeRect.width, _cursorChangeRect.height);
|
|
}
|
|
if (Event.current.type == EventType.MouseUp)
|
|
_isResize = false;
|
|
}
|
|
|
|
private void DisplayTabs()
|
|
{
|
|
GUILayout.BeginVertical(_s.ProjectBrowserIconAreaBg, GUILayout.Width(_currentTabViewWidth));
|
|
_tabsScrollPosition = GUILayout.BeginScrollView(_tabsScrollPosition);
|
|
if (!_isEditMode)
|
|
{
|
|
for (int i = 0; i < tabs.Count; i++)
|
|
{
|
|
var buttonStyle = i == _tabIndex ? _s.SelectionRect : _s.RectangleToolSelection;
|
|
|
|
if (_isEditMode && i == _tabIndex)
|
|
{
|
|
GUILayout.BeginVertical();
|
|
tabs[i].tabName = EditorGUILayout.TextField(tabs[i].tabName, _s.expandWidth200);
|
|
GUILayout.EndVertical();
|
|
}
|
|
else
|
|
{
|
|
if (GUILayout.Button(tabs[i].tabName, buttonStyle, GUILayout.Width(_currentTabViewWidth-5)))
|
|
{
|
|
_tabIndex = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_tabsReorderableList.DoLayoutList();
|
|
}
|
|
|
|
GUILayout.EndScrollView();
|
|
GUILayout.EndVertical();
|
|
ResizeScrollView();
|
|
}
|
|
|
|
private void AddNewTab()
|
|
{
|
|
if (tabs.Count == 0)
|
|
{
|
|
tabs.Add(new CacheTabInfo { id = 0, tabName = "New tab", list = new List<CacheObjectInfo>() });
|
|
}
|
|
else
|
|
{
|
|
tabs.Add(new CacheTabInfo
|
|
{ id = tabs.Max(s => s.id) + 1, tabName = "New tab", list = new List<CacheObjectInfo>() });
|
|
}
|
|
|
|
Save();
|
|
}
|
|
|
|
private void Filter()
|
|
{
|
|
if (string.IsNullOrEmpty(searchText))
|
|
{
|
|
filterList = objects;
|
|
}
|
|
else
|
|
{
|
|
var temp = searchText.ToLower();
|
|
filterList = objects.Where(s => s.Name.ToLower().Contains(temp)).ToList();
|
|
}
|
|
|
|
_objectsReorderableList =
|
|
new ReorderableList(filterList, typeof(CacheObjectInfo), true, false, false, false);
|
|
_objectsReorderableList.drawElementCallback += DrawObjectElementCallback;
|
|
_objectsReorderableList.onChangedCallback += _ => { Save(); };
|
|
}
|
|
|
|
private void DrawObjectElementCallback(Rect rect, int index, bool isactive, bool isfocused)
|
|
{
|
|
var data = filterList[index];
|
|
var avatarRect = new Rect(rect.x, rect.y, rect.height, rect.height);
|
|
GUI.Label(avatarRect, data.previewTexture);
|
|
var nameRect = new Rect(rect.x + rect.height + 3, rect.y, rect.width - rect.height - 3, rect.height);
|
|
GUI.Label(nameRect, data.GetDisplayName());
|
|
}
|
|
|
|
private void DrawTabElementCallback(Rect rect, int index, bool isactive, bool isfocused)
|
|
{
|
|
var data = tabs[index];
|
|
var nameRect = new Rect(rect.x, rect.y, rect.width, rect.height);
|
|
data.tabName = GUI.TextField(nameRect, data.tabName);
|
|
}
|
|
|
|
void UpdateDragAndDrop()
|
|
{
|
|
if (Event.current.type == EventType.DragUpdated)
|
|
{
|
|
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
|
|
Event.current.Use();
|
|
}
|
|
else if (Event.current.type == EventType.DragPerform)
|
|
{
|
|
DragAndDrop.AcceptDrag();
|
|
if (DragAndDrop.paths.Length == 0 && DragAndDrop.objectReferences.Length > 0)
|
|
{
|
|
foreach (Object obj in DragAndDrop.objectReferences)
|
|
{
|
|
var currentPrefab = UnityEditor.SceneManagement.PrefabStageUtility.GetCurrentPrefabStage();
|
|
// Debug.Log("- " + obj);
|
|
string assetPath = obj.name;
|
|
GetScenePath((obj as GameObject).transform, ref assetPath);
|
|
var item = new CacheObjectInfo
|
|
{
|
|
Name = obj.name,
|
|
path = assetPath,
|
|
};
|
|
|
|
//CacheObjectLocation location = CacheObjectLocation.Assets;
|
|
if (currentPrefab != null)
|
|
{
|
|
item.prefabPath = currentPrefab.assetPath;
|
|
item.location = CacheObjectLocation.Prefab;
|
|
}
|
|
else
|
|
{
|
|
item.location = CacheObjectLocation.Scene;
|
|
}
|
|
|
|
if (objects.Find(s => s.obj == item.obj) == null)
|
|
{
|
|
objects.Add(item);
|
|
Save();
|
|
}
|
|
else if (objects.Find(s => s.path == item.path) == null)
|
|
{
|
|
objects.Add(item);
|
|
Save();
|
|
}
|
|
}
|
|
|
|
Filter();
|
|
}
|
|
else if (DragAndDrop.paths.Length > 0 && DragAndDrop.objectReferences.Length == 0)
|
|
{
|
|
foreach (string path in DragAndDrop.paths)
|
|
{
|
|
Debug.Log("- " + path);
|
|
}
|
|
}
|
|
else if (DragAndDrop.paths.Length == DragAndDrop.objectReferences.Length)
|
|
{
|
|
for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
|
|
{
|
|
Object obj = DragAndDrop.objectReferences[i];
|
|
if (objects.Find(s => s.obj == obj) == null)
|
|
{
|
|
objects.Add(new CacheObjectInfo()
|
|
{
|
|
Name = obj.name,
|
|
location = CacheObjectLocation.Assets,
|
|
obj = obj,
|
|
});
|
|
Save();
|
|
}
|
|
}
|
|
|
|
Filter();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void GetScenePath(Transform obj, ref string path)
|
|
{
|
|
var parent = obj.parent;
|
|
if (parent != null)
|
|
{
|
|
path = parent.name + "/" + path;
|
|
GetScenePath(parent, ref path);
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class CacheObjectInfo
|
|
{
|
|
public Object obj;
|
|
public string path;
|
|
public string prefabPath;
|
|
public string Name;
|
|
public CacheObjectLocation location;
|
|
public Texture2D previewTexture;
|
|
|
|
public string GetDisplayName()
|
|
{
|
|
return $"{GetPrefix()} {Name}";
|
|
}
|
|
|
|
public string GetPrefix()
|
|
{
|
|
if (location == CacheObjectLocation.Assets)
|
|
return "A:";
|
|
if (location == CacheObjectLocation.Scene)
|
|
return "S:";
|
|
return "P:";
|
|
}
|
|
|
|
public void Ping()
|
|
{
|
|
if (location == CacheObjectLocation.Assets)
|
|
{
|
|
Selection.activeObject = obj;
|
|
EditorGUIUtility.PingObject(obj);
|
|
}
|
|
else if (location == CacheObjectLocation.Prefab)
|
|
{
|
|
AssetDatabase.OpenAsset(AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)));
|
|
var rootGameObjects = UnityEditor.SceneManagement.PrefabStageUtility.GetCurrentPrefabStage().prefabContentsRoot;
|
|
|
|
var arrayPath = path.Split('/').ToList();
|
|
arrayPath.RemoveAt(0);
|
|
arrayPath.RemoveAt(0);
|
|
var newPath = string.Join("/", arrayPath);
|
|
var obj = rootGameObjects.transform.Find(newPath);
|
|
if (obj != null)
|
|
{
|
|
Selection.activeObject = obj;
|
|
EditorGUIUtility.PingObject(obj);
|
|
}
|
|
}
|
|
else if (location == CacheObjectLocation.Scene)
|
|
{
|
|
if (UnityEditor.SceneManagement.PrefabStageUtility.GetCurrentPrefabStage() != null)
|
|
{
|
|
PrefabUtility.UnloadPrefabContents(
|
|
UnityEditor.SceneManagement.PrefabStageUtility.GetCurrentPrefabStage().prefabContentsRoot);
|
|
}
|
|
|
|
var arrayPath = path.Split('/').ToList();
|
|
arrayPath.RemoveAt(0);
|
|
var newPath = string.Join("/", arrayPath);
|
|
|
|
if (arrayPath.Count == 0)
|
|
newPath = path;
|
|
|
|
Transform obj = null;
|
|
for (int i = 0; i < SceneManager.sceneCount; i++)
|
|
{
|
|
bool check = false;
|
|
var scene = SceneManager.GetSceneAt(i);
|
|
var rootGameObjects = scene.GetRootGameObjects().ToList();
|
|
foreach (var gameObject in rootGameObjects)
|
|
{
|
|
obj = gameObject.transform.Find(newPath);
|
|
if (obj != null)
|
|
{
|
|
check = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (check)
|
|
break;
|
|
|
|
var tempObj = rootGameObjects.Find(s => s.name == newPath);
|
|
if (tempObj != null)
|
|
{
|
|
obj = tempObj.transform;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (obj != null)
|
|
{
|
|
Selection.activeObject = obj;
|
|
EditorGUIUtility.PingObject(obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Save()
|
|
{
|
|
string data = JsonUtility.ToJson(new EditorCacheSave { tabs = tabs });
|
|
EditorPrefs.SetString(Application.dataPath + StrSaveName, data);
|
|
}
|
|
|
|
private void Read()
|
|
{
|
|
var data = EditorPrefs.GetString(Application.dataPath + StrSaveName);
|
|
EditorCacheSave editorCacheSave;
|
|
if (string.IsNullOrEmpty(data))
|
|
{
|
|
editorCacheSave = new EditorCacheSave
|
|
{ tabs = new List<CacheTabInfo> { new CacheTabInfo() { id = 0, tabName = "Common" } } };
|
|
}
|
|
else
|
|
{
|
|
editorCacheSave = JsonUtility.FromJson<EditorCacheSave>(data);
|
|
}
|
|
|
|
tabs.Clear();
|
|
tabs.AddRange(editorCacheSave.tabs);
|
|
InitReOrderTabList();
|
|
}
|
|
|
|
[Serializable]
|
|
public class EditorCacheSave
|
|
{
|
|
public List<CacheTabInfo> tabs = new List<CacheTabInfo>();
|
|
}
|
|
|
|
public enum CacheObjectLocation
|
|
{
|
|
Assets,
|
|
Scene,
|
|
Prefab,
|
|
}
|
|
|
|
[Serializable]
|
|
public class CacheTabInfo
|
|
{
|
|
public int id;
|
|
public string tabName;
|
|
public List<CacheObjectInfo> list;
|
|
public CacheObjectInfo selected;
|
|
public Editor editor;
|
|
}
|
|
}
|
|
|
|
public class EditorCacheStyle
|
|
{
|
|
public readonly GUILayoutOption expandWidthFalse = GUILayout.ExpandWidth(false);
|
|
public readonly GUILayoutOption expandWidth200 = GUILayout.Width(100);
|
|
public readonly GUILayoutOption expandWidth210 = GUILayout.Width(110);
|
|
public readonly GUIStyle previewTexture;
|
|
public readonly GUIStyle buttonStyle;
|
|
public readonly GUIStyle textEmpty;
|
|
public readonly GUIStyle toolBar;
|
|
|
|
public readonly GUIStyle buttonLeftSelected;
|
|
public readonly GUIStyle buttonMidSelected;
|
|
public readonly GUIStyle buttonRightSelected;
|
|
|
|
public readonly GUIStyle toolbarSeachTextField;
|
|
public readonly GUIStyle RectangleToolSelection;
|
|
public readonly GUIStyle ProjectBrowserIconAreaBg;
|
|
public readonly GUIStyle RectangleToolVBar;
|
|
public readonly GUIStyle SelectionRect;
|
|
|
|
public EditorCacheStyle()
|
|
{
|
|
toolbarSeachTextField = GUI.skin.GetStyle("ToolbarSearchTextField");
|
|
ProjectBrowserIconAreaBg = GUI.skin.GetStyle("ProjectBrowserIconAreaBg");
|
|
RectangleToolSelection = GUI.skin.GetStyle("RectangleToolSelection");
|
|
RectangleToolVBar = GUI.skin.GetStyle("RectangleToolVBar");
|
|
SelectionRect = GUI.skin.GetStyle("SelectionRect");
|
|
previewTexture = new GUIStyle { fixedWidth = 20, fixedHeight = 20 };
|
|
buttonLeftSelected = new GUIStyle(EditorStyles.miniButtonLeft);
|
|
buttonMidSelected = new GUIStyle(EditorStyles.miniButtonMid);
|
|
buttonRightSelected = new GUIStyle(EditorStyles.miniButtonRight);
|
|
buttonLeftSelected.normal.textColor = buttonMidSelected.normal.textColor =
|
|
buttonRightSelected.normal.textColor = Color.yellow;
|
|
buttonLeftSelected.onHover.textColor = buttonMidSelected.onHover.textColor =
|
|
buttonRightSelected.onHover.textColor = Color.yellow;
|
|
|
|
buttonLeftSelected.focused.textColor = buttonMidSelected.focused.textColor =
|
|
buttonRightSelected.focused.textColor = Color.yellow;
|
|
|
|
buttonLeftSelected.fontStyle = buttonMidSelected.fontStyle =
|
|
buttonRightSelected.fontStyle = FontStyle.Bold;
|
|
|
|
ColorUtility.TryParseHtmlString("#363636", out var bgColor);
|
|
buttonStyle = new GUIStyle("Button");
|
|
buttonStyle.alignment = TextAnchor.MiddleLeft;
|
|
textEmpty = new GUIStyle(EditorStyles.label);
|
|
textEmpty.alignment = TextAnchor.MiddleCenter;
|
|
toolBar = new GUIStyle(EditorStyles.toolbar);
|
|
toolBar.fixedHeight = 60;
|
|
}
|
|
}
|
|
|
|
public static class EditorCacheHelper
|
|
{
|
|
public static void ShowFolderContents(int folderInstanceID)
|
|
{
|
|
Assembly editorAssembly = typeof(Editor).Assembly;
|
|
Type projectBrowserType = editorAssembly.GetType("UnityEditor.ProjectBrowser");
|
|
MethodInfo showFolderContents = projectBrowserType.GetMethod(
|
|
"ShowFolderContents", BindingFlags.Instance | BindingFlags.NonPublic);
|
|
Object[] projectBrowserInstances = Resources.FindObjectsOfTypeAll(projectBrowserType);
|
|
if (projectBrowserInstances.Length > 0)
|
|
{
|
|
for (int i = 0; i < projectBrowserInstances.Length; i++)
|
|
ShowFolderContentsInternal(projectBrowserInstances[i], showFolderContents, folderInstanceID);
|
|
}
|
|
else
|
|
{
|
|
EditorWindow projectBrowser = OpenNewProjectBrowser(projectBrowserType);
|
|
ShowFolderContentsInternal(projectBrowser, showFolderContents, folderInstanceID);
|
|
}
|
|
}
|
|
|
|
private static void ShowFolderContentsInternal(Object projectBrowser, MethodInfo showFolderContents,
|
|
int folderInstanceID)
|
|
{
|
|
SerializedObject serializedObject = new SerializedObject(projectBrowser);
|
|
bool inTwoColumnMode = serializedObject.FindProperty("m_ViewMode").enumValueIndex == 1;
|
|
|
|
if (!inTwoColumnMode)
|
|
{
|
|
MethodInfo setTwoColumns = projectBrowser.GetType().GetMethod(
|
|
"SetTwoColumns", BindingFlags.Instance | BindingFlags.NonPublic);
|
|
setTwoColumns.Invoke(projectBrowser, null);
|
|
}
|
|
|
|
bool revealAndFrameInFolderTree = true;
|
|
showFolderContents.Invoke(projectBrowser, new object[] { folderInstanceID, revealAndFrameInFolderTree });
|
|
}
|
|
|
|
private static EditorWindow OpenNewProjectBrowser(Type projectBrowserType)
|
|
{
|
|
EditorWindow projectBrowser = EditorWindow.GetWindow(projectBrowserType);
|
|
projectBrowser.Show();
|
|
MethodInfo init = projectBrowserType.GetMethod("Init", BindingFlags.Instance | BindingFlags.Public);
|
|
init.Invoke(projectBrowser, null);
|
|
return projectBrowser;
|
|
}
|
|
}
|
|
} |